From aec1b8dddc68ecb8288ec6132932e4c7b4bca09f Mon Sep 17 00:00:00 2001
From: Ash Wolf <ninji@wuffs.org>
Date: Tue, 10 Jan 2023 11:05:21 +0000
Subject: getting close to done
---
compiler_and_linker/unsorted/CABI.c | 2049 +++++++++++-
compiler_and_linker/unsorted/CClass.c | 2295 +++++++++++++-
compiler_and_linker/unsorted/CDecl.c | 325 +-
compiler_and_linker/unsorted/CError.c | 107 +-
compiler_and_linker/unsorted/CException.c | 33 +-
compiler_and_linker/unsorted/CExpr.c | 286 +-
compiler_and_linker/unsorted/CExpr2.c | 185 +-
compiler_and_linker/unsorted/CExprConvMatch.c | 2517 +++++++++++++++
compiler_and_linker/unsorted/CFunc.c | 3263 +++++++++++++++++++-
compiler_and_linker/unsorted/CInit.c | 30 +-
compiler_and_linker/unsorted/CMangler.c | 117 +-
compiler_and_linker/unsorted/CParser.c | 130 +-
compiler_and_linker/unsorted/CPrec.c | 1772 +++++++++--
compiler_and_linker/unsorted/CodeGen.c | 135 +-
compiler_and_linker/unsorted/CodeGenOptPPC.c | 107 +-
compiler_and_linker/unsorted/Exceptions.c | 4 +-
compiler_and_linker/unsorted/FuncLevelAsmPPC.c | 2 +-
compiler_and_linker/unsorted/GCCInlineAsm.c | 215 +-
compiler_and_linker/unsorted/InlineAsm.c | 2 +-
compiler_and_linker/unsorted/InlineAsmPPC.c | 65 +-
compiler_and_linker/unsorted/InstrSelection.c | 227 +-
compiler_and_linker/unsorted/IrOptimizer.c | 381 ++-
compiler_and_linker/unsorted/IroCSE.c | 17 +-
compiler_and_linker/unsorted/IroEval.c | 914 ++++++
compiler_and_linker/unsorted/IroFlowgraph.c | 106 +-
compiler_and_linker/unsorted/IroLoop.c | 10 +-
compiler_and_linker/unsorted/IroPointerAnalysis.c | 1128 +++----
.../unsorted/IroPointerAnalysisADTs.c | 934 +++---
compiler_and_linker/unsorted/IroTransform.c | 2793 ++++++++++++++++-
compiler_and_linker/unsorted/IroUnrollLoop.c | 2264 +++++++++++++-
compiler_and_linker/unsorted/IroUtil.c | 37 +-
compiler_and_linker/unsorted/IroVars.c | 2 +-
compiler_and_linker/unsorted/LoopOptimization.c | 26 +-
compiler_and_linker/unsorted/RegisterInfo.c | 27 +-
compiler_and_linker/unsorted/StackFrame.c | 6 +-
compiler_and_linker/unsorted/TOC.c | 282 +-
36 files changed, 20073 insertions(+), 2720 deletions(-)
(limited to 'compiler_and_linker/unsorted')
diff --git a/compiler_and_linker/unsorted/CABI.c b/compiler_and_linker/unsorted/CABI.c
index 3e99ca0..91883f5 100644
--- a/compiler_and_linker/unsorted/CABI.c
+++ b/compiler_and_linker/unsorted/CABI.c
@@ -1,11 +1,30 @@
#include "compiler/CABI.h"
+#include "compiler/CClass.h"
+#include "compiler/CDecl.h"
+#include "compiler/CError.h"
+#include "compiler/CException.h"
+#include "compiler/CExpr.h"
+#include "compiler/CFunc.h"
+#include "compiler/CInit.h"
+#include "compiler/CInline.h"
#include "compiler/CMachine.h"
-#include "compiler/types.h"
+#include "compiler/CMangler.h"
+#include "compiler/CParser.h"
+#include "compiler/CScope.h"
+#include "compiler/CSOM.h"
#include "compiler/CompilerTools.h"
+#include "compiler/objects.h"
+#include "compiler/scopes.h"
+#include "compiler/types.h"
-static void *trans_vtboffsets; // TODO type
-static void *cabi_pathroot; // TODO type - 8 byte struct??
-static void *cabi_pathcur; // TODO type
+typedef struct OffsetList {
+ struct OffsetList *next;
+ SInt32 offset;
+} OffsetList;
+
+static OffsetList *trans_vtboffsets;
+static BClassList cabi_pathroot;
+static BClassList *cabi_pathcur;
static TypeClass *cabi_loop_class;
static Boolean cabi_loop_construct;
@@ -21,21 +40,271 @@ Type *CABI_GetPtrDiffTType(void) {
return (Type *) &stsignedlong;
}
-SInt16 CABI_StructSizeAlignValue(Type *type, SInt32 size) {}
+SInt16 CABI_StructSizeAlignValue(Type *type, SInt32 size) {
+ SInt16 align = CMach_GetTypeAlign(type);
+ if (align <= 1)
+ return 0;
+ else
+ return (align - 1) & (align - ((size & (align - 1))));
+}
+
+void CABI_ReverseBitField(TypeBitfield *tbitfield) {
+ UInt8 bits;
+ UInt8 a;
+ UInt8 b;
+
+ switch (tbitfield->bitfieldtype->size) {
+ case 1:
+ bits = 8;
+ break;
+ case 2:
+ bits = 16;
+ break;
+ case 4:
+ bits = 32;
+ break;
+ case 8:
+ bits = 64;
+ break;
+ default:
+ CError_FATAL(172);
+ }
+
+ b = tbitfield->unkB;
+ a = tbitfield->unkA;
+ tbitfield->unkA = (bits - a) - b;
+}
+
+static void CABI_AllocateZeroVTablePointer(void *unk, TypeClass *tclass) {
+ ClassList *base;
+
+ for (base = tclass->bases; base; base = base->next) {
+ if (!base->is_virtual && base->base->vtable)
+ return;
+ }
+
+ tclass->size += void_ptr.size;
+}
+
+static SInt32 CABI_GetBaseSize(TypeClass *tclass) {
+ SInt32 size = tclass->size;
+
+ if (copts.vbase_abi_v2 && tclass->vbases)
+ return tclass->vbases->offset;
+
+ return size;
+}
+
+static void CABI_AllocateBases(DeclE *decle, TypeClass *tclass) {
+ Boolean flag;
+ TypeClass *baseclass;
+ ClassList *base;
+ VClassList *vbase;
+ SInt32 size;
+
+ flag = 0;
+ size = tclass->size;
+
+ for (base = tclass->bases; base; base = base->next) {
+ if (!base->is_virtual) {
+ baseclass = base->base;
+ if (!(baseclass->flags & CLASS_FLAGS_1000)) {
+ base->offset = size + CMach_MemberAlignValue(TYPE(baseclass), size);
+ if (copts.vbase_abi_v2) {
+ size = base->offset + CABI_GetBaseSize(baseclass);
+ } else {
+ size = base->offset + baseclass->size;
+ for (vbase = baseclass->vbases; vbase; vbase = vbase->next)
+ size -= vbase->base->size;
+ }
+ flag = 0;
+ } else {
+ if (flag)
+ base->offset = ++size;
+ else
+ base->offset = size;
+ flag = 1;
+ }
+ }
+ }
+
+ tclass->size = size;
+}
+
+static void CABI_AllocateVirtualBasePointers(DeclE *decle, TypeClass *tclass) {
+ ClassList *base;
+ SInt32 size;
+
+ size = tclass->size;
+
+ for (base = tclass->bases; base; base = base->next) {
+ if (base->is_virtual) {
+ base->offset = size + CMach_MemberAlignValue(TYPE(&void_ptr), size);
+ size = base->offset + void_ptr.size;
+ }
+ }
+
+ tclass->size = size;
+}
-void CABI_ReverseBitField(TypeBitfield *tbitfield) {}
+static SInt32 CABI_GetMemberOffset(TypeClass *tclass, HashNameNode *name) {
+ ObjMemberVar *ivar;
-// not sure about the sig for this, it's unused lmao
-static void CABI_AllocateZeroVTablePointer() {}
+ if (!name)
+ return 0;
+
+ ivar = tclass->ivars;
+ while (1) {
+ if (ivar->name == name)
+ return ivar->offset;
+
+ if (!(ivar = ivar->next))
+ CError_FATAL(362);
+ }
+}
+
+static void CABI_AllocateMembers(DeclE *decle, TypeClass *tclass) {
+ ObjMemberVar *ivar;
+ SInt32 initialSize;
+ SInt32 maxSize;
+ TypeClass *unionClass;
+ SInt32 unionStart;
+ Boolean inAnonUnion;
+ Boolean removeNoNameIvars;
+
+ removeNoNameIvars = 0;
+ initialSize = maxSize = tclass->size;
+ CMach_StructLayoutInitOffset(maxSize);
+
+ unionClass = NULL;
+ for (ivar = tclass->ivars; ivar; ivar = ivar->next) {
+ if (!ivar->anonunion) {
+ if (!(ivar->offset & 0x80000000)) {
+ if (tclass->mode == CLASS_MODE_1)
+ CMach_StructLayoutInitOffset(initialSize);
+
+ if (IS_TYPE_BITFIELD(ivar->type))
+ ivar->offset = CMach_StructLayoutBitfield(TYPE_BITFIELD(ivar->type), ivar->qual);
+ else
+ ivar->offset = CMach_StructLayoutGetOffset(ivar->type, ivar->qual);
+
+ if (tclass->mode == CLASS_MODE_1) {
+ SInt32 tmp = CMach_StructLayoutGetCurSize();
+ if (tmp > maxSize)
+ maxSize = tmp;
+ }
+
+ unionClass = NULL;
+ } else {
+ CError_ASSERT(412, unionClass);
+ ivar->offset = unionStart + CABI_GetMemberOffset(unionClass, ivar->name);
+ if (!inAnonUnion)
+ ivar->anonunion = 1;
+ inAnonUnion = 0;
+ }
+
+ if (ivar->name == no_name_node || ivar->name == NULL)
+ removeNoNameIvars = 1;
+ } else {
+ CError_ASSERT(422, IS_TYPE_CLASS(ivar->type));
+
+ if (tclass->mode == CLASS_MODE_1)
+ CMach_StructLayoutInitOffset(initialSize);
+
+ unionStart = CMach_StructLayoutGetOffset(ivar->type, ivar->qual);
+ unionClass = TYPE_CLASS(ivar->type);
+ inAnonUnion = 1;
+
+ if (tclass->mode == CLASS_MODE_1) {
+ SInt32 tmp = CMach_StructLayoutGetCurSize();
+ if (tmp > maxSize)
+ maxSize = tmp;
+ }
+
+ removeNoNameIvars = 1;
+ }
+
+ if (decle->vtable_ivar == ivar)
+ tclass->vtable->offset = ivar->offset;
+ }
+
+ if (removeNoNameIvars) {
+ ObjMemberVar **ptr = &tclass->ivars;
+ while (*ptr) {
+ if ((*ptr)->name == NULL || (*ptr)->name == no_name_node)
+ *ptr = (*ptr)->next;
+ else
+ ptr = &(*ptr)->next;
+ }
+ }
+
+ if (tclass->mode == CLASS_MODE_1)
+ tclass->size = maxSize;
+ else
+ tclass->size = CMach_StructLayoutGetCurSize();
+
+ if (copts.reverse_bitfields) {
+ for (ivar = tclass->ivars; ivar; ivar = ivar->next) {
+ if (IS_TYPE_BITFIELD(ivar->type))
+ CABI_ReverseBitField(TYPE_BITFIELD(ivar->type));
+ }
+ }
+}
+
+static void CABI_AllocateVirtualBases(DeclE *decle, TypeClass *tclass) {
+ VClassList *vbase;
+ SInt32 size;
+
+ size = tclass->size;
+
+ for (vbase = tclass->vbases; vbase; vbase = vbase->next) {
+ vbase->offset = size + CMach_MemberAlignValue(TYPE(vbase->base), size);
+ size = vbase->offset + CABI_GetBaseSize(vbase->base);
+
+ if (vbase->has_override)
+ size += CMach_MemberAlignValue(TYPE(&stunsignedlong), size) + 4;
+ }
+
+ tclass->size = size;
+}
-static SInt32 CABI_GetBaseSize(TypeClass *tclass) {}
-static void CABI_AllocateBases() {}
-static void CABI_AllocateVirtualBasePointers() {}
-static void CABI_GetMemberOffset() {}
-static void CABI_AllocateMembers() {}
-static void CABI_AllocateVirtualBases() {}
-static void CABI_FindZeroDeltaVPtr() {}
-static void CABI_FindZeroVirtualBaseMember() {}
+static Boolean CABI_FindZeroDeltaVPtr(TypeClass *tclass) {
+ ClassList *base;
+
+ for (base = tclass->bases; base; base = base->next) {
+ if (!base->is_virtual && base->base->vtable && !base->offset) {
+ tclass->vtable->offset = base->base->vtable->offset;
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+static Object *CABI_FindZeroVirtualBaseMember(TypeClass *tclass, Object *obj) {
+ NameSpaceObjectList *nsol;
+ ClassList *base;
+ Object *chk;
+
+ for (base = tclass->bases; base; base = base->next) {
+ if (!base->is_virtual && !base->offset && !base->voffset && base->base->vtable) {
+ for (nsol = CScope_FindName(base->base->nspace, obj->name); nsol; nsol = nsol->next) {
+ chk = OBJECT(nsol->object);
+ if (
+ chk->otype == OT_OBJECT &&
+ chk->datatype == DVFUNC &&
+ CClass_GetOverrideKind(TYPE_FUNC(chk->type), TYPE_FUNC(obj->type), 0) == 1
+ )
+ return chk;
+ }
+
+ if ((chk = CABI_FindZeroVirtualBaseMember(base->base, obj)))
+ return chk;
+ }
+ }
+
+ return NULL;
+}
void CABI_AddVTable(TypeClass *tclass) {
tclass->vtable = galloc(sizeof(VTable));
@@ -46,48 +315,1714 @@ SInt32 CABI_GetVTableOffset(TypeClass *tclass) {
return 0;
}
-static void CABI_GetBaseVTableSize() {}
-static void CABI_ApplyClassFlags() {}
-static void CABI_AllocateVTable() {}
-void CABI_LayoutClass(DeclE *decle, TypeClass *tclass) {}
-void CABI_MakeDefaultArgConstructor(TypeClass *tclass, Object *obj) {}
-static void CABI_ThisArg() {}
-ENode *CABI_MakeThisExpr(TypeClass *tclass, SInt32 offset) {}
-static void CABI_VArg() {}
-static void CABI_MakeVArgExpr() {}
-static void CABI_MakeCopyConArgExpr() {}
-static void CABI_InitVBasePtr1() {}
-static void CABI_InitVBasePtrs() {}
-static void CABI_GetVBasePath() {}
-static void CABI_GetVBasePtr() {}
-static SInt32 CABI_FindNVBase(TypeClass *tclass, TypeClass *base, SInt32 offset) {}
-SInt32 CABI_GetCtorOffsetOffset(TypeClass *tclass, TypeClass *base) {}
-static void CABI_InitVBaseCtorOffsets() {}
-static void CABI_InitVTablePtrs() {}
-static Boolean CABI_IsOperatorNew(Object *obj) {}
-Object *CABI_ConstructorCallsNew(TypeClass *tclass) {}
-void CABI_TransConstructor(Object *obj, Statement *stmt, TypeClass *tclass, TransConstructorCallback callback, Boolean flag) {}
-void CABI_MakeDefaultConstructor(TypeClass *tclass, Object *obj) {}
-static void CABI_AssignObject() {}
-static void CABI_FindIntegralSizeType() {}
-static void CABI_AppendCopyRegion() {}
-static void CABI_ClassInitLoopCallBack() {}
-static void CABI_CopyConAssignCB() {}
-void CABI_MakeDefaultCopyConstructor(TypeClass *tclass, Object *obj) {}
-void CABI_MakeDefaultAssignmentOperator(TypeClass *tclass, Object *obj) {}
-static void CABI_DestroyMembers() {}
-static void CABI_DestroyBases() {}
-static void CABI_DestroyVBases() {}
-void CABI_TransDestructor(Object *obj1, Object *obj2, Statement *stmt, TypeClass *tclass) {}
-void CABI_MakeDefaultDestructor(TypeClass *tclass, Object *obj) {}
-static void CABI_CreateLayeredDestructor() {}
-void CABI_MakeLayeredDestructor(TypeClass *tclass, Object *obj) {}
-
-Object *CABI_GetDestructorObject(Object *obj, int what) {
+static SInt32 CABI_GetBaseVTableSize(TypeClass *tclass) {
+ VClassList *vbase;
+ SInt32 size;
+
+ size = tclass->vtable->size;
+
+ for (vbase = tclass->vbases; vbase; vbase = vbase->next) {
+ if (vbase->base->vtable)
+ size -= CABI_GetBaseVTableSize(vbase->base);
+ }
+
+ return size;
+}
+
+static void CABI_ApplyClassFlags(Object *obj, UInt8 flags, Boolean unused) {
+ if (flags & CLASS_EFLAGS_INTERNAL)
+ obj->flags |= OBJECT_FLAGS_10;
+ if (flags & CLASS_EFLAGS_IMPORT)
+ obj->flags |= OBJECT_FLAGS_20;
+ if (flags & CLASS_EFLAGS_EXPORT)
+ obj->flags |= OBJECT_FLAGS_40;
+}
+
+static void CABI_AllocateVTable(DeclE *decle, TypeClass *tclass) {
+ SInt32 size;
+ ObjBase *objbase;
+ Object *obj;
+ ObjMemberVar *ivar;
+ ClassList *base;
+ VClassList *vbase;
+ int i;
+
+ size = 0;
+
+ if (!tclass->vtable) {
+ CABI_AddVTable(tclass);
+ decle->xA = decle->x8 - 1;
+ }
+
+ if (!CABI_FindZeroDeltaVPtr(tclass)) {
+ ivar = galloc(sizeof(ObjMemberVar));
+ memclrw(ivar, sizeof(ObjMemberVar));
+
+ ivar->otype = OT_MEMBERVAR;
+ ivar->access = ACCESSPUBLIC;
+ ivar->name = vptr_name_node;
+ ivar->type = TYPE(&void_ptr);
+ decle->vtable_ivar = ivar;
+
+ for (i = decle->xA; ; i--) {
+ if (i < 0) {
+ ivar->next = tclass->ivars;
+ tclass->ivars = ivar;
+ break;
+ }
+
+ CError_ASSERT(666, decle->objlist[i]);
+
+ if (decle->objlist[i]->otype == OT_MEMBERVAR) {
+ ivar->next = OBJ_MEMBER_VAR(decle->objlist[i])->next;
+ OBJ_MEMBER_VAR(decle->objlist[i])->next = ivar;
+ break;
+ }
+ }
+
+ if (tclass->flags & (CLASS_FLAGS_10 | CLASS_FLAGS_2000))
+ size = void_ptr.size;
+ else
+ size = 8;
+ } else {
+ decle->vtable_ivar = NULL;
+ }
+
+ for (base = tclass->bases; base; base = base->next) {
+ if (base->base->vtable && !base->is_virtual) {
+ base->voffset = size;
+ if (copts.vbase_abi_v2) {
+ size += CABI_GetBaseVTableSize(base->base);
+ } else {
+ size += base->base->vtable->size;
+ for (vbase = base->base->vbases; vbase; vbase = vbase->next) {
+ if (vbase->base->vtable)
+ size -= vbase->base->vtable->size;
+ }
+ }
+ }
+ }
+
+ for (i = 0; i < decle->x8; i++) {
+ CError_ASSERT(714, objbase = decle->objlist[i]);
+
+ if (objbase->otype == OT_OBJECT && OBJECT(objbase)->datatype == DVFUNC) {
+ TypeMethod *tmethod = TYPE_METHOD(OBJECT(objbase)->type);
+ Object *baseobj = CABI_FindZeroVirtualBaseMember(tclass, OBJECT(objbase));
+
+ if (baseobj) {
+ tmethod->x1E = TYPE_METHOD(baseobj->type)->x1E;
+ } else {
+ tmethod->x1E = size;
+ size += 4;
+ }
+ }
+ }
+
+ for (vbase = tclass->vbases; vbase; vbase = vbase->next) {
+ if (vbase->base->vtable) {
+ vbase->voffset = size;
+ if (copts.vbase_abi_v2)
+ size += CABI_GetBaseVTableSize(vbase->base);
+ else
+ size += vbase->base->vtable->size;
+ }
+ }
+
+ obj = CParser_NewCompilerDefDataObject();
+ CABI_ApplyClassFlags(obj, tclass->eflags, 0);
+
+ obj->name = CMangler_VTableName(tclass);
+ obj->type = CDecl_NewStructType(size, 4);
+ obj->qual = Q_CONST;
+ obj->nspace = tclass->nspace;
+ switch (tclass->action) {
+ case CLASS_ACTION_0:
+ obj->sclass = TK_STATIC;
+ obj->qual |= Q_20000;
+ break;
+ }
+
+ CParser_UpdateObject(obj, NULL);
+
+ tclass->vtable->object = obj;
+ tclass->vtable->owner = tclass;
+ tclass->vtable->size = size;
+}
+
+void CABI_LayoutClass(DeclE *decle, TypeClass *tclass) {
+ char saveAlignMode = copts.align_mode;
+
+ tclass->size = 0;
+ if (!tclass->sominfo) {
+ if (tclass->bases)
+ CABI_AllocateBases(decle, tclass);
+ if (tclass->flags & CLASS_FLAGS_20)
+ CABI_AllocateVirtualBasePointers(decle, tclass);
+ if (decle->xC)
+ CABI_AllocateVTable(decle, tclass);
+ CABI_AllocateMembers(decle, tclass);
+ if (tclass->flags & CLASS_FLAGS_20)
+ CABI_AllocateVirtualBases(decle, tclass);
+ } else {
+ copts.align_mode = AlignMode2_PPC;
+ CABI_AllocateMembers(decle, tclass);
+ }
+
+ tclass->align = CMach_GetClassAlign(tclass);
+ if (tclass->size == 0) {
+ tclass->size = 1;
+ tclass->flags |= CLASS_FLAGS_1000;
+ } else {
+ tclass->size += CABI_StructSizeAlignValue(TYPE(tclass), tclass->size);
+ }
+
+ tclass->flags |= CLASS_FLAGS_2;
+
+ copts.align_mode = saveAlignMode;
+}
+
+void CABI_MakeDefaultArgConstructor(TypeClass *tclass, Object *func) {
+ DefArgCtorInfo *info;
+ Boolean saveDebugInfo;
+ ENodeList *copied;
+ FuncArg *args;
+ ENodeList *argexprs;
+ CScopeSave savedScope;
+ Statement firstStmt;
+ Statement returnStmt;
+
+ CError_FATAL(860);
+
+ if (anyerrors || func->access == ACCESSNONE)
+ return;
+
+ CError_ASSERT(866, info = func->u.func.defargdata);
+
+ CABI_ApplyClassFlags(func, tclass->eflags, 0);
+
+ CScope_SetFunctionScope(func, &savedScope);
+
+ CFunc_FuncGenSetup(&firstStmt, func);
+
+ saveDebugInfo = copts.isGeneratingDebugInfo;
+ copts.isGeneratingDebugInfo = 0;
+
+ CFunc_SetupNewFuncArgs(func, TYPE_FUNC(func->type)->args);
+
+ if (tclass->flags & CLASS_FLAGS_20)
+ arguments->next->object->name = no_name_node;
+
+ firstStmt.next = &returnStmt;
+
+ memclrw(&returnStmt, sizeof(Statement));
+ returnStmt.type = ST_RETURN;
+ returnStmt.expr = lalloc(sizeof(ENode));
+ returnStmt.expr->type = EFUNCCALL;
+ returnStmt.expr->cost = 200;
+ returnStmt.expr->flags = 0;
+ returnStmt.expr->rtype = TYPE(&void_ptr);
+
+ returnStmt.expr->data.funccall.funcref = CExpr_MakeObjRefNode(info->default_func, 0);
+ returnStmt.expr->data.funccall.functype = TYPE_FUNC(info->default_func->type);
+ args = TYPE_FUNC(info->default_func->type)->args;
+ returnStmt.expr->data.funccall.args = lalloc(sizeof(ENodeList));
+ argexprs = returnStmt.expr->data.funccall.args;
+
+ argexprs->node = create_objectnode(arguments->object);
+
+ if (tclass->flags & CLASS_FLAGS_20) {
+ args = args->next;
+ argexprs->next = lalloc(sizeof(ENodeList));
+ argexprs = argexprs->next;
+ argexprs->node = create_objectnode(arguments->next->object);
+ }
+
+ args = args->next;
+ argexprs->next = lalloc(sizeof(ENodeList));
+ argexprs = argexprs->next;
+ argexprs->node = CInline_CopyExpression(info->default_arg, CopyMode0);
+
+ while ((args = args->next) && args->dexpr) {
+ argexprs->next = lalloc(sizeof(ENodeList));
+ argexprs = argexprs->next;
+ argexprs->node = CInline_CopyExpression(args->dexpr, CopyMode0);
+ }
+
+ argexprs->next = NULL;
+
+ CFunc_CodeCleanup(&firstStmt);
+ CFunc_Gen(&firstStmt, func, 0);
+
+ CScope_RestoreScope(&savedScope);
+ copts.isGeneratingDebugInfo = saveDebugInfo;
+
+ func->u.func.defargdata = NULL;
+}
+
+static Object *CABI_ThisArg(void) {
+ CError_ASSERT(931, arguments && IS_TYPE_POINTER_ONLY(arguments->object->type));
+ return arguments->object;
+}
+
+ENode *CABI_MakeThisExpr(TypeClass *tclass, SInt32 offset) {
+ ENode *expr;
+
+ if (tclass) {
+ if (!tclass->sominfo) {
+ expr = create_objectnode(CABI_ThisArg());
+ if (tclass->flags & CLASS_FLAGS_1)
+ expr = makemonadicnode(expr, EINDIRECT);
+ } else {
+ expr = CSOM_SOMSelfObjectExpr(tclass);
+ }
+ } else {
+ expr = create_objectnode(CABI_ThisArg());
+ expr->rtype = TYPE(&void_ptr);
+ }
+
+ if (offset)
+ expr = makediadicnode(expr, intconstnode(TYPE(&stunsignedlong), offset), EADD);
+
+ return expr;
+}
+
+static Object *CABI_VArg(void) {
+ CError_ASSERT(976, arguments && arguments->next && IS_TYPE_INT(arguments->next->object->type));
+ return arguments->next->object;
+}
+
+static ENode *CABI_MakeVArgExpr(void) {
+ return create_objectnode(CABI_VArg());
+}
+
+static ENode *CABI_MakeCopyConArgExpr(TypeClass *tclass, Boolean flag) {
+ ObjectList *args;
+
+ CError_ASSERT(1000, args = arguments);
+ CError_ASSERT(1001, args = args->next);
+ if (flag && (tclass->flags & CLASS_FLAGS_20))
+ CError_ASSERT(1002, args = args->next);
+ CError_ASSERT(1003, IS_TYPE_POINTER_ONLY(args->object->type));
+
+ return create_objectnode(args->object);
+}
+
+static ENode *CABI_InitVBasePtr1(ENode *expr, TypeClass *tclass1, TypeClass *tclass2, TypeClass *tclass3, SInt32 offset) {
+ ClassList *base;
+ SInt32 newOffset;
+ OffsetList *list;
+
+ for (base = tclass2->bases; base; base = base->next) {
+ if (base->base == tclass3 && base->is_virtual) {
+ newOffset = offset + base->offset;
+
+ for (list = trans_vtboffsets; list; list = list->next) {
+ if (newOffset == list->offset)
+ break;
+ }
+
+ if (!list) {
+ list = lalloc(sizeof(OffsetList));
+ list->offset = newOffset;
+ list->next = trans_vtboffsets;
+ trans_vtboffsets = list;
+
+ expr = makediadicnode(
+ makemonadicnode(CABI_MakeThisExpr(NULL, newOffset), EINDIRECT),
+ expr,
+ EASS);
+ }
+ }
+
+ if (base->is_virtual)
+ newOffset = CClass_VirtualBaseOffset(tclass1, base->base);
+ else
+ newOffset = offset + base->offset;
+
+ expr = CABI_InitVBasePtr1(expr, tclass1, base->base, tclass3, newOffset);
+ }
+
+ return expr;
+}
+
+static Statement *CABI_InitVBasePtrs(Statement *stmt, TypeClass *tclass) {
+ ENode *expr;
+ VClassList *vbase;
+
+ for (vbase = tclass->vbases, trans_vtboffsets = NULL; vbase; vbase = vbase->next) {
+ expr = CABI_InitVBasePtr1(CABI_MakeThisExpr(NULL, vbase->offset), tclass, tclass, vbase->base, 0);
+ stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+ stmt->expr = expr;
+ }
+
+ return stmt;
+}
+
+static OffsetList *CABI_GetVBasePath(TypeClass *tclass, TypeClass *baseclass) {
+ ClassList *base;
+ OffsetList *best;
+ OffsetList *list;
+ OffsetList *scan;
+ short bestLength;
+ short length;
+
+ for (base = tclass->bases; base; base = base->next) {
+ if (base->base == baseclass && base->is_virtual) {
+ best = lalloc(sizeof(OffsetList));
+ best->next = NULL;
+ best->offset = base->offset;
+ return best;
+ }
+ }
+
+ best = NULL;
+
+ for (base = tclass->bases; base; base = base->next) {
+ if ((list = CABI_GetVBasePath(base->base, baseclass))) {
+ for (scan = list->next, length = 1; scan; scan = scan->next)
+ length++;
+
+ if (base->is_virtual)
+ length++;
+
+ if (!best || length < bestLength) {
+ if (base->is_virtual) {
+ best = lalloc(sizeof(OffsetList));
+ best->next = list;
+ best->offset = base->offset;
+ } else {
+ best = list;
+ best->offset += base->offset;
+ }
+ bestLength = length;
+ }
+ }
+ }
+
+ return best;
+}
+
+static ENode *CABI_GetVBasePtr(TypeClass *tclass, TypeClass *baseclass) {
+ OffsetList *path;
+ ENode *expr;
+
+ CError_ASSERT(1127, path = CABI_GetVBasePath(tclass, baseclass));
+
+ expr = makemonadicnode(CABI_MakeThisExpr(NULL, path->offset), EINDIRECT);
+
+ while ((path = path->next)) {
+ if (path->offset)
+ expr = makediadicnode(expr, intconstnode(TYPE(&stunsignedlong), path->offset), EADD);
+ expr = makemonadicnode(expr, EINDIRECT);
+ }
+
+ return expr;
+}
+
+static SInt32 CABI_FindNVBase(TypeClass *tclass, TypeClass *baseclass, SInt32 offset) {
+ ClassList *base;
+ SInt32 tmp;
+
+ if (tclass == baseclass)
+ return offset;
+
+ for (base = tclass->bases; base; base = base->next) {
+ if (!base->is_virtual && (tmp = CABI_FindNVBase(base->base, baseclass, offset + base->offset)) >= 0)
+ return tmp;
+ }
+
+ return -1;
+}
+
+SInt32 CABI_GetCtorOffsetOffset(TypeClass *tclass, TypeClass *baseclass) {
+ SInt32 baseSize;
+ SInt32 size;
+ char saveAlignMode;
+
+ size = CABI_GetBaseSize(tclass);
+ if (baseclass) {
+ baseSize = CABI_FindNVBase(tclass, baseclass, 0);
+ CError_ASSERT(1178, baseSize >= 0);
+ size -= baseSize;
+ }
+
+ saveAlignMode = copts.align_mode;
+ if (tclass->eflags & CLASS_EFLAGS_F0)
+ copts.align_mode = ((tclass->eflags & CLASS_EFLAGS_F0) >> 4) - 1;
+ size += CMach_MemberAlignValue(TYPE(&stunsignedlong), size);
+ copts.align_mode = saveAlignMode;
+
+ return size;
+}
+
+static Statement *CABI_InitVBaseCtorOffsets(Statement *stmt, TypeClass *tclass) {
+ VClassList *vbase;
+ Object *tempObj;
+ ENode *expr;
+ ENode *vbaseptr;
+ SInt32 vboffset;
+ SInt32 ctorOffsetOffset;
+
+ tempObj = NULL;
+
+ for (vbase = tclass->vbases; vbase; vbase = vbase->next) {
+ if (vbase->has_override) {
+ if (!tempObj)
+ tempObj = create_temp_object(TYPE(&void_ptr));
+
+ vboffset = CClass_VirtualBaseOffset(tclass, vbase->base);
+ ctorOffsetOffset = CABI_GetCtorOffsetOffset(vbase->base, NULL);
+ vbaseptr = CABI_GetVBasePtr(tclass, vbase->base);
+ CError_ASSERT(1215, vbaseptr);
+
+ expr = makediadicnode(create_objectnode(tempObj), vbaseptr, EASS);
+ stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+ stmt->expr = expr;
+
+ expr = makediadicnode(
+ create_objectnode(tempObj),
+ intconstnode(TYPE(&stunsignedlong), ctorOffsetOffset),
+ EADD);
+ expr = makemonadicnode(expr, EINDIRECT);
+ expr->rtype = TYPE(&stunsignedlong);
+ expr = makediadicnode(
+ expr,
+ makediadicnode(
+ CABI_MakeThisExpr(NULL, vboffset),
+ create_objectnode(tempObj),
+ ESUB),
+ EASS);
+ stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+ stmt->expr = expr;
+ }
+ }
+
+ return stmt;
+}
+
+static Statement *CABI_InitVTablePtrs(Statement *stmt, Object *vtableObj, TypeClass *tclass, TypeClass *baseclass, SInt32 offset, SInt32 voffset) {
+ ClassList *base;
+ BClassList *orig_pathcur;
+ SInt32 newOffset;
+ SInt32 newVOffset;
+ OffsetList *offsetList;
+ SInt32 vtblOffset;
+ ENode *vtblExpr;
+ ENode *pathExpr;
+ BClassList path;
+
+ if (baseclass->vtable->owner == baseclass) {
+ vtblOffset = offset + baseclass->vtable->offset;
+ for (offsetList = trans_vtboffsets; offsetList; offsetList = offsetList->next) {
+ if (vtblOffset == offsetList->offset)
+ break;
+ }
+
+ if (!offsetList) {
+ offsetList = lalloc(sizeof(OffsetList));
+ offsetList->offset = vtblOffset;
+ offsetList->next = trans_vtboffsets;
+ trans_vtboffsets = offsetList;
+
+ vtblExpr = create_objectrefnode(vtableObj);
+ vtblExpr->rtype = TYPE(&void_ptr);
+ if ((vtblOffset = voffset + CABI_GetVTableOffset(baseclass)))
+ vtblExpr = makediadicnode(vtblExpr, intconstnode(TYPE(&stunsignedlong), vtblOffset), EADD);
+
+ pathExpr = CClass_AccessPathCast(&cabi_pathroot, CABI_MakeThisExpr(tclass, 0), 0);
+ if (baseclass->vtable->offset && !canadd(pathExpr, baseclass->vtable->offset)) {
+ pathExpr = makediadicnode(pathExpr, intconstnode(TYPE(&stunsignedlong), baseclass->vtable->offset), EADD);
+ optimizecomm(pathExpr);
+ }
+
+ stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+ stmt->expr = makediadicnode(makemonadicnode(pathExpr, EINDIRECT), vtblExpr, EASS);
+ }
+ }
+
+ for (base = baseclass->bases; base; base = base->next) {
+ if (base->base->vtable) {
+ orig_pathcur = cabi_pathcur;
+
+ cabi_pathcur->next = &path;
+ path.next = NULL;
+ path.type = TYPE(base->base);
+ cabi_pathcur = &path;
+
+ if (base->is_virtual) {
+ newOffset = CClass_VirtualBaseOffset(tclass, base->base);
+ newVOffset = CClass_VirtualBaseVTableOffset(tclass, base->base);
+ } else {
+ newOffset = offset + base->offset;
+ newVOffset = voffset + base->voffset;
+ }
+
+ stmt = CABI_InitVTablePtrs(stmt, vtableObj, tclass, base->base, newOffset, newVOffset);
+
+ cabi_pathcur = orig_pathcur;
+ }
+ }
+
+ return stmt;
+}
+
+static Boolean CABI_IsOperatorNew(ObjBase *obj) {
+ return
+ obj->otype == OT_OBJECT &&
+ IS_TYPE_FUNC(OBJECT(obj)->type) &&
+ TYPE_FUNC(OBJECT(obj)->type)->args &&
+ TYPE_FUNC(OBJECT(obj)->type)->args->type == CABI_GetSizeTType() &&
+ !TYPE_FUNC(OBJECT(obj)->type)->args->next;
+}
+
+Object *CABI_ConstructorCallsNew(TypeClass *tclass) {
+ NameSpaceObjectList *nsol;
+ CScopeParseResult pr;
+
+ if (!tclass->sominfo && (tclass->flags & CLASS_FLAGS_1)) {
+ if (CScope_FindClassMemberObject(tclass, &pr, CMangler_OperatorName(TK_NEW))) {
+ if (pr.obj_10) {
+ if (CABI_IsOperatorNew(pr.obj_10))
+ return OBJECT(pr.obj_10);
+ } else {
+ for (nsol = pr.nsol_14; nsol; nsol = nsol->next) {
+ if (CABI_IsOperatorNew(nsol->object))
+ return OBJECT(nsol->object);
+ }
+ }
+ }
+
+ return newh_func;
+ }
+
+ return NULL;
+}
+
+void CABI_TransConstructor(Object *obj, Statement *firstStmt, TypeClass *tclass, TransConstructorCallback callback, Boolean has_try) {
+ Statement *stmt;
+ Object *tmpfunc;
+ Object *tmpfunc2;
+ CLabel *label;
+ ENode *expr;
+ ClassList *base;
+ VClassList *vbase;
+ ObjMemberVar *ivar;
+ Type *type;
+ CtorChain *chain;
+ Boolean errorflag;
+
+ stmt = firstStmt;
+
+ if ((tmpfunc = CABI_ConstructorCallsNew(tclass))) {
+ label = newlabel();
+
+ stmt = CFunc_InsertStatement(ST_IFGOTO, firstStmt);
+ stmt->expr = CABI_MakeThisExpr(NULL, 0);
+ stmt->label = label;
+
+ expr = makediadicnode(
+ CABI_MakeThisExpr(NULL, 0),
+ funccallexpr(tmpfunc, intconstnode(CABI_GetSizeTType(), tclass->size), NULL, NULL, NULL),
+ EASS);
+ stmt = CFunc_InsertStatement(ST_IFGOTO, stmt);
+ stmt->expr = expr;
+ stmt->label = label;
+
+ stmt = CFunc_InsertStatement(ST_RETURN, stmt);
+ stmt->expr = NULL;
+
+ stmt = CFunc_InsertStatement(ST_LABEL, stmt);
+ stmt->label = label;
+ label->stmt = stmt;
+ }
+
+ if (has_try) {
+ for (stmt = firstStmt; ; stmt = stmt->next) {
+ CError_ASSERT(1408, stmt);
+ if (stmt->type == ST_BEGINCATCH)
+ break;
+ }
+ }
+
+ if (!tclass->sominfo) {
+ if (tclass->flags & CLASS_FLAGS_20) {
+ label = newlabel();
+
+ stmt = CFunc_InsertStatement(ST_IFGOTO, stmt);
+ stmt->expr = CExpr_New_EEQU_Node(CABI_MakeVArgExpr(), intconstnode(TYPE(&stsignedshort), 0));
+ stmt->label = label;
+
+ stmt = CABI_InitVBasePtrs(stmt, tclass);
+
+ for (vbase = tclass->vbases; vbase; vbase = vbase->next) {
+ if (!callback) {
+ for (chain = ctor_chain; chain; chain = chain->next) {
+ if (chain->what == CtorChain_VBase && chain->u.vbase == vbase)
+ break;
+ }
+
+ if (chain) {
+ stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+ stmt->expr = chain->objexpr;
+ } else {
+ expr = CClass_DefaultConstructorCall(
+ vbase->base,
+ tclass,
+ CABI_MakeThisExpr(NULL, vbase->offset),
+ 0, 1, 1, &errorflag);
+ if (expr) {
+ stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+ stmt->expr = expr;
+ } else if (errorflag) {
+ CError_Error(CErrorStr213, tclass, 0, vbase->base, 0);
+ }
+ }
+ } else {
+ stmt = callback(stmt, tclass, vbase->base, vbase->offset, 1);
+ }
+
+ if ((tmpfunc = CClass_Destructor(vbase->base)))
+ CExcept_RegisterMember(stmt, CABI_ThisArg(), vbase->offset, tmpfunc, CABI_VArg(), 0);
+ }
+
+ stmt = CFunc_InsertStatement(ST_LABEL, stmt);
+ stmt->label = label;
+ label->stmt = stmt;
+ }
+
+ for (base = tclass->bases; base; base = base->next) {
+ if (base->is_virtual)
+ continue;
+
+ if (!callback) {
+ for (chain = ctor_chain; chain; chain = chain->next) {
+ if (chain->what == CtorChain_Base && chain->u.base == base)
+ break;
+ }
+
+ if (chain) {
+ stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+ stmt->expr = chain->objexpr;
+ } else {
+ expr = CClass_DefaultConstructorCall(
+ base->base,
+ tclass,
+ CABI_MakeThisExpr(NULL, base->offset),
+ 0, 1, 0, &errorflag);
+ if (expr) {
+ stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+ stmt->expr = expr;
+ } else if (errorflag) {
+ CError_Error(CErrorStr213, tclass, 0, base->base, 0);
+ }
+ }
+ } else {
+ stmt = callback(stmt, tclass, base->base, base->offset, 1);
+ }
+
+ if ((tmpfunc = CClass_Destructor(base->base)))
+ CExcept_RegisterMember(stmt, CABI_ThisArg(), base->offset, tmpfunc, NULL, 0);
+ }
+
+ if (tclass->vtable && tclass->vtable->object && tclass->vtable->owner == tclass) {
+ cabi_pathroot.next = NULL;
+ cabi_pathroot.type = TYPE(tclass);
+ cabi_pathcur = &cabi_pathroot;
+ trans_vtboffsets = NULL;
+
+ stmt = CABI_InitVTablePtrs(stmt, tclass->vtable->object, tclass, tclass, 0, 0);
+ }
+ }
+
+ if (!tclass->sominfo && (tclass->flags & CLASS_FLAGS_8000))
+ stmt = CABI_InitVBaseCtorOffsets(stmt, tclass);
+
+ if (!callback) {
+ for (ivar = tclass->ivars; ivar; ivar = ivar->next) {
+ for (chain = ctor_chain; chain; chain = chain->next) {
+ if (chain->what == CtorChain_MemberVar && chain->u.membervar == ivar) {
+ if (IS_TYPE_ARRAY(ivar->type))
+ chain = NULL;
+ break;
+ }
+ }
+
+ if (chain) {
+ stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+ stmt->expr = chain->objexpr;
+ type = ivar->type;
+ switch (type->type) {
+ case TYPEARRAY:
+ do {
+ type = TPTR_TARGET(type);
+ } while (IS_TYPE_ARRAY(type));
+ if (IS_TYPE_CLASS(type)) {
+ if ((tmpfunc = CClass_Destructor(TYPE_CLASS(type)))) {
+ CError_ASSERT(1560, type->size);
+ CExcept_RegisterMemberArray(
+ stmt,
+ CABI_ThisArg(),
+ ivar->offset,
+ tmpfunc,
+ ivar->type->size / type->size,
+ type->size);
+ }
+ }
+ break;
+ case TYPECLASS:
+ if ((tmpfunc = CClass_Destructor(TYPE_CLASS(type)))) {
+ CExcept_RegisterMember(
+ stmt,
+ CABI_ThisArg(),
+ ivar->offset,
+ tmpfunc,
+ NULL,
+ 1);
+ }
+ break;
+ }
+ } else {
+ type = ivar->type;
+ switch (type->type) {
+ case TYPEARRAY:
+ do {
+ type = TPTR_TARGET(type);
+ } while (IS_TYPE_ARRAY(type));
+ if (IS_TYPE_CLASS(type) && CClass_Constructor(TYPE_CLASS(type))) {
+ if (
+ (tmpfunc = CClass_DefaultConstructor(TYPE_CLASS(type))) ||
+ (tmpfunc = CClass_DummyDefaultConstructor(TYPE_CLASS(type)))
+ )
+ {
+ tmpfunc2 = CClass_Destructor(TYPE_CLASS(type));
+ if (tmpfunc2)
+ tmpfunc2 = CABI_GetDestructorObject(tmpfunc2, 1);
+
+ stmt = CInit_ConstructClassArray(
+ stmt,
+ TYPE_CLASS(type),
+ tmpfunc,
+ tmpfunc2,
+ CABI_MakeThisExpr(tclass, ivar->offset),
+ ivar->type->size / type->size);
+
+ if (tmpfunc2)
+ CExcept_RegisterMemberArray(
+ stmt,
+ CABI_ThisArg(),
+ ivar->offset,
+ tmpfunc2,
+ ivar->type->size / type->size,
+ type->size);
+ } else {
+ CError_Error(CErrorStr214, tclass, 0, ivar->name->name);
+ }
+ }
+ break;
+ case TYPECLASS:
+ expr = CClass_DefaultConstructorCall(
+ TYPE_CLASS(type),
+ NULL,
+ CABI_MakeThisExpr(tclass, ivar->offset),
+ 1, 1, 0, &errorflag);
+ if (expr) {
+ stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+ stmt->expr = expr;
+ } else if (errorflag) {
+ CError_Error(CErrorStr214, tclass, 0, ivar->name->name);
+ }
+
+ if ((tmpfunc = CClass_Destructor(TYPE_CLASS(type)))) {
+ if (!expr) {
+ stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+ stmt->expr = nullnode();
+ }
+ CExcept_RegisterMember(
+ stmt,
+ CABI_ThisArg(),
+ ivar->offset,
+ tmpfunc,
+ NULL,
+ 1);
+ }
+ break;
+ }
+ }
+ }
+ } else {
+ stmt = callback(stmt, tclass, NULL, 0, 1);
+ }
+
+ if (!tclass->sominfo) {
+ for (stmt = firstStmt->next; stmt; stmt = stmt->next) {
+ if (stmt->type == ST_RETURN) {
+ CError_ASSERT(1661, !stmt->expr);
+ stmt->expr = CABI_MakeThisExpr(NULL, 0);
+ }
+ }
+ }
+}
+
+void CABI_MakeDefaultConstructor(TypeClass *tclass, Object *func) {
+ Boolean saveDebugInfo;
+ CScopeSave savedScope;
+ Statement firstStmt;
+ Statement returnStmt;
+
+ if (anyerrors || func->access == ACCESSNONE)
+ return;
+
+ CABI_ApplyClassFlags(func, tclass->eflags, 0);
+
+ CScope_SetFunctionScope(func, &savedScope);
+
+ CFunc_FuncGenSetup(&firstStmt, func);
+
+ saveDebugInfo = copts.isGeneratingDebugInfo;
+ copts.isGeneratingDebugInfo = 0;
+
+ CFunc_SetupNewFuncArgs(func, TYPE_FUNC(func->type)->args);
+
+ ctor_chain = NULL;
+ if (tclass->flags & CLASS_FLAGS_20)
+ arguments->next->object->name = CParser_GetUniqueName();
+
+ firstStmt.next = &returnStmt;
+
+ memclrw(&returnStmt, sizeof(Statement));
+ returnStmt.type = ST_RETURN;
+
+ CABI_TransConstructor(func, &firstStmt, tclass, NULL, 0);
+
+ CFunc_CodeCleanup(&firstStmt);
+ CFunc_Gen(&firstStmt, func, 0);
+
+ CScope_RestoreScope(&savedScope);
+ copts.isGeneratingDebugInfo = saveDebugInfo;
+}
+
+static ENode *CABI_AssignObject(TypeClass *tclass, ENode *expr1, ENode *expr2) {
+ Object *assignfunc;
+ FuncArg *arg;
+
+ assignfunc = CClass_AssignmentOperator(tclass);
+ if (!assignfunc) {
+ expr1 = makemonadicnode(expr1, EINDIRECT);
+ expr1->rtype = TYPE(tclass);
+ return makediadicnode(expr1, expr2, EASS);
+ }
+
+ CError_ASSERT(1731,
+ IS_TYPE_FUNC(assignfunc->type) &&
+ (arg = TYPE_FUNC(assignfunc->type)->args) &&
+ (arg = arg->next));
+
+ expr2 = argumentpromotion(expr2, arg->type, arg->qual, 1);
+ return funccallexpr(assignfunc, expr1, expr2, NULL, NULL);
+}
+
+static Type *CABI_FindIntegralSizeType(SInt32 size) {
+ if (stunsignedchar.size == size)
+ return TYPE(&stunsignedchar);
+ if (stunsignedshort.size == size)
+ return TYPE(&stunsignedshort);
+ if (stunsignedint.size == size)
+ return TYPE(&stunsignedint);
+ if (stunsignedlong.size == size)
+ return TYPE(&stunsignedlong);
+ if (stunsignedlonglong.size == size)
+ return TYPE(&stunsignedlonglong);
+
+ CError_FATAL(1756);
+ return NULL;
+}
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+typedef struct CopyRegion {
+ struct CopyRegion *next;
+ Type *type;
+ SInt32 start;
+ SInt32 end;
+ Boolean flag;
+} CopyRegion;
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+static CopyRegion *CABI_AppendCopyRegion(CopyRegion *regions, Type *type, SInt32 start, Boolean flag) {
+ CopyRegion *region;
+ SInt32 end;
+
+ if (IS_TYPE_BITFIELD(type))
+ type = TYPE_BITFIELD(type)->bitfieldtype;
+
+ end = start + type->size;
+
+ if (flag) {
+ for (region = regions; region; region = region->next) {
+ if (region->flag) {
+ if (region->start <= start && region->end >= end)
+ return regions;
+
+ if (region->start >= start && region->end <= end) {
+ region->type = type;
+ region->start = start;
+ region->end = end;
+ for (region = region->next; region; region = region->next) {
+ if (region->start >= start && region->end <= end)
+ region->end = region->start;
+ }
+ return regions;
+ }
+ }
+ }
+ }
+
+ if (regions) {
+ region = regions;
+ while (region->next)
+ region = region->next;
+
+ region->next = lalloc(sizeof(CopyRegion));
+ region = region->next;
+ } else {
+ regions = lalloc(sizeof(CopyRegion));
+ region = regions;
+ }
+
+ region->next = NULL;
+ region->type = type;
+ region->start = start;
+ region->end = end;
+ region->flag = flag;
+
+ return regions;
+}
+
+static ENode *CABI_ClassInitLoopCallBack(ENode *var1, ENode *var2) {
+ ENodeList *list;
+
+ var2 = makemonadicnode(var2, EINDIRECT);
+ var2->rtype = TYPE(cabi_loop_class);
+
+ if (cabi_loop_construct) {
+ list = lalloc(sizeof(ENodeList));
+ memclrw(list, sizeof(ENodeList));
+ list->node = var2;
+ return CExpr_ConstructObject(cabi_loop_class, var1, list, 1, 1, 0, 1, 1);
+ } else {
+ return CABI_AssignObject(cabi_loop_class, var1, var2);
+ }
+}
+
+static Statement *CABI_CopyConAssignCB(Statement *stmt, TypeClass *tclass, TypeClass *baseclass, SInt32 offset, Boolean flag) {
+ ENode *expr;
+ ENode *expr2;
+ ENode *startExpr;
+ ENode *endExpr;
+ ENodeList *list;
+ ObjMemberVar *ivar;
+ CopyRegion *regions;
+ Type *type;
+ SInt32 i;
+ SInt32 count;
+ Boolean isFlagNotSet;
+ Object *tmpfunc;
+
+ if (baseclass) {
+ if (baseclass->flags & CLASS_FLAGS_1000) {
+ if (
+ (flag && !CClass_CopyConstructor(baseclass)) ||
+ (!flag && !CClass_AssignmentOperator(baseclass))
+ )
+ return stmt;
+ }
+
+ expr = CABI_MakeCopyConArgExpr(tclass, flag);
+ expr->rtype = TYPE(baseclass);
+ expr->data.monadic = CClass_DirectBasePointerCast(expr->data.monadic, tclass, baseclass);
+
+ stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+ if (flag) {
+ list = lalloc(sizeof(ENodeList));
+ list->next = NULL;
+ list->node = expr;
+
+ stmt->expr = CExpr_ConstructObject(
+ baseclass,
+ CABI_MakeThisExpr(NULL, offset),
+ list,
+ 1, 0, 0, 0, 1);
+ } else {
+ stmt->expr = CABI_AssignObject(
+ baseclass,
+ CClass_DirectBasePointerCast(CABI_MakeThisExpr(NULL, 0), tclass, baseclass),
+ expr);
+ }
+ } else {
+ isFlagNotSet = !flag;
+ for (ivar = tclass->ivars, regions = NULL; ivar; ivar = ivar->next) {
+ if (ivar->name == vptr_name_node)
+ continue;
+
+ type = ivar->type;
+ if (isFlagNotSet) {
+ if (CParser_IsConst(type, ivar->qual) || IS_TYPE_REFERENCE(type) != 0) {
+ CError_Error(CErrorStr387, tclass, 0);
+ isFlagNotSet = 0;
+ }
+ }
+
+ switch (type->type) {
+ case TYPEARRAY:
+ while (IS_TYPE_ARRAY(type))
+ type = TPTR_TARGET(type);
+ if (!IS_TYPE_CLASS(type)) {
+ regions = CABI_AppendCopyRegion(regions, ivar->type, ivar->offset, 1);
+ break;
+ }
+ case TYPECLASS:
+ if (flag) {
+ if (CClass_CopyConstructor(TYPE_CLASS(type)) || CClass_CopyConstructor(TYPE_CLASS(type))) {
+ regions = CABI_AppendCopyRegion(regions, ivar->type, ivar->offset, 0);
+ break;
+ }
+ } else {
+ if (CClass_AssignmentOperator(TYPE_CLASS(type))) {
+ regions = CABI_AppendCopyRegion(regions, ivar->type, ivar->offset, 0);
+ break;
+ }
+ }
+ default:
+ regions = CABI_AppendCopyRegion(regions, ivar->type, ivar->offset, 1);
+ }
+ }
+
+ for (; regions; regions = regions->next) {
+ if (regions->start >= regions->end)
+ continue;
+
+ type = regions->type;
+ expr = CABI_MakeCopyConArgExpr(tclass, flag);
+ expr->rtype = type;
+
+ if (!canadd(expr->data.monadic, regions->start)) {
+ expr->data.monadic = makediadicnode(
+ expr->data.monadic,
+ intconstnode(TYPE(&stunsignedlong), regions->start),
+ EADD);
+ optimizecomm(expr->data.monadic);
+ }
+
+ if (!regions->flag) {
+ if (IS_TYPE_ARRAY(type)) {
+ while (IS_TYPE_ARRAY(type))
+ type = TPTR_TARGET(type);
+
+ CError_ASSERT(1966, IS_TYPE_CLASS(type));
+
+ if (type->size) {
+ count = regions->type->size / type->size;
+ if (count > 4) {
+ startExpr = CABI_MakeThisExpr(tclass, regions->start);
+ endExpr = CABI_MakeThisExpr(tclass, regions->start + regions->type->size);
+ expr = CABI_MakeCopyConArgExpr(tclass, flag)->data.monadic;
+ if (!canadd(expr, regions->start)) {
+ expr = makediadicnode(
+ expr,
+ intconstnode(TYPE(&stunsignedlong), regions->start),
+ EADD);
+ optimizecomm(expr);
+ }
+
+ cabi_loop_class = TYPE_CLASS(type);
+ cabi_loop_construct = flag;
+ stmt = CFunc_GenerateLoop(
+ stmt,
+ CDecl_NewPointerType(type),
+ startExpr,
+ endExpr,
+ intconstnode(TYPE(&stunsignedlong), type->size),
+ expr,
+ CABI_ClassInitLoopCallBack);
+ } else {
+ for (i = 0, offset = regions->start; i < count; offset += type->size, i++) {
+ expr = CABI_MakeCopyConArgExpr(tclass, flag);
+ expr->rtype = type;
+
+ if (!canadd(expr->data.monadic, offset)) {
+ expr->data.monadic = makediadicnode(
+ expr->data.monadic,
+ intconstnode(TYPE(&stunsignedlong), offset),
+ EADD);
+ optimizecomm(expr->data.monadic);
+ }
+
+ stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+ if (flag) {
+ list = lalloc(sizeof(ENodeList));
+ memclrw(list, sizeof(ENodeList));
+ list->node = expr;
+ stmt->expr = CExpr_ConstructObject(
+ TYPE_CLASS(type),
+ CABI_MakeThisExpr(tclass, offset),
+ list,
+ 1, 1, 0, 1, 1);
+ } else {
+ stmt->expr = CABI_AssignObject(
+ TYPE_CLASS(type),
+ CABI_MakeThisExpr(tclass, offset),
+ expr);
+ }
+ }
+ }
+
+ if (flag && (tmpfunc = CClass_Destructor(TYPE_CLASS(type))))
+ CExcept_RegisterMemberArray(stmt, CABI_ThisArg(), regions->start, tmpfunc, count, type->size);
+ }
+ } else {
+ CError_ASSERT(2027, IS_TYPE_CLASS(type));
+
+ stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+
+ if (flag) {
+ list = lalloc(sizeof(ENodeList));
+ memclrw(list, sizeof(ENodeList));
+ list->node = expr;
+ stmt->expr = CExpr_ConstructObject(
+ TYPE_CLASS(type),
+ CABI_MakeThisExpr(tclass, regions->start),
+ list,
+ 1, 1, 0, 1, 1);
+
+ if ((tmpfunc = CClass_Destructor(TYPE_CLASS(type))))
+ CExcept_RegisterMember(stmt, CABI_ThisArg(), regions->start, tmpfunc, NULL, 1);
+ } else {
+ stmt->expr = CABI_AssignObject(
+ TYPE_CLASS(type),
+ CABI_MakeThisExpr(tclass, regions->start),
+ expr);
+ }
+ }
+ } else {
+ if (IS_TYPE_ARRAY(type)) {
+ if (type->size > 1 && ((regions->start & 1) || (type->size & 1))) {
+ stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+ stmt->expr = funccallexpr(
+ copy_func,
+ CABI_MakeThisExpr(tclass, regions->start),
+ getnodeaddress(expr, 0),
+ intconstnode(CABI_GetSizeTType(), type->size),
+ NULL);
+ continue;
+ }
+
+ type = CDecl_NewStructType(type->size, CMach_GetTypeAlign(type));
+ expr->rtype = type;
+ }
+
+ expr2 = makemonadicnode(CABI_MakeThisExpr(tclass, regions->start), EINDIRECT);
+ expr2->rtype = type;
+ stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+ stmt->expr = makediadicnode(expr2, expr, EASS);
+ }
+ }
+ }
+
+ return stmt;
+}
+
+void CABI_MakeDefaultCopyConstructor(TypeClass *tclass, Object *func) {
+ Boolean saveDebugInfo;
+ CScopeSave savedScope;
+ Statement firstStmt;
+ Statement returnStmt;
+
+ if (anyerrors || func->access == ACCESSNONE)
+ return;
+
+ CABI_ApplyClassFlags(func, tclass->eflags, 0);
+
+ CScope_SetFunctionScope(func, &savedScope);
+
+ CFunc_FuncGenSetup(&firstStmt, func);
+
+ saveDebugInfo = copts.isGeneratingDebugInfo;
+ copts.isGeneratingDebugInfo = 0;
+
+ CFunc_SetupNewFuncArgs(func, TYPE_FUNC(func->type)->args);
+
+ ctor_chain = NULL;
+ if (tclass->flags & CLASS_FLAGS_20)
+ arguments->next->object->name = CParser_GetUniqueName();
+
+ firstStmt.next = &returnStmt;
+
+ memclrw(&returnStmt, sizeof(Statement));
+ returnStmt.type = ST_RETURN;
+
+ CABI_TransConstructor(func, &firstStmt, tclass, CABI_CopyConAssignCB, 0);
+
+ CFunc_CodeCleanup(&firstStmt);
+ CFunc_Gen(&firstStmt, func, 0);
+
+ CScope_RestoreScope(&savedScope);
+ copts.isGeneratingDebugInfo = saveDebugInfo;
+}
+
+void CABI_MakeDefaultAssignmentOperator(TypeClass *tclass, Object *func) {
+ Boolean saveDebugInfo;
+ Statement *stmt;
+ ClassList *base;
+ VClassList *vbase;
+ ENode *expr1;
+ ENode *expr2;
+ CScopeSave savedScope;
+ Statement firstStmt;
+
+ if (anyerrors || func->access == ACCESSNONE)
+ return;
+
+ CABI_ApplyClassFlags(func, tclass->eflags, 0);
+
+ CScope_SetFunctionScope(func, &savedScope);
+
+ CFunc_FuncGenSetup(&firstStmt, func);
+
+ saveDebugInfo = copts.isGeneratingDebugInfo;
+ copts.isGeneratingDebugInfo = 0;
+
+ CFunc_SetupNewFuncArgs(func, TYPE_FUNC(func->type)->args);
+
+ stmt = curstmt;
+
+ if (tclass->mode == CLASS_MODE_1) {
+ expr1 = makemonadicnode(CABI_MakeThisExpr(tclass, 0), EINDIRECT);
+ expr1->rtype = TYPE(tclass);
+
+ expr2 = CABI_MakeCopyConArgExpr(tclass, 0);
+ expr2->rtype = TYPE(tclass);
+
+ stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+ stmt->expr = makediadicnode(expr1, expr2, EASS);
+ } else {
+ for (vbase = tclass->vbases; vbase; vbase = vbase->next) {
+ stmt = CABI_CopyConAssignCB(stmt, tclass, vbase->base, vbase->offset, 0);
+ }
+
+ for (base = tclass->bases; base; base = base->next) {
+ if (!base->is_virtual)
+ stmt = CABI_CopyConAssignCB(stmt, tclass, base->base, base->offset, 0);
+ }
+
+ stmt = CABI_CopyConAssignCB(stmt, tclass, NULL, 0, 0);
+ }
+
+ stmt = CFunc_InsertStatement(ST_RETURN, stmt);
+ stmt->expr = CABI_MakeThisExpr(NULL, 0);
+
+ CFunc_CodeCleanup(&firstStmt);
+ CFunc_Gen(&firstStmt, func, 0);
+
+ CScope_RestoreScope(&savedScope);
+ copts.isGeneratingDebugInfo = saveDebugInfo;
+}
+
+static Statement *CABI_DestroyMembers(Statement *stmt, ObjMemberVar *ivars, TypeClass *tclass) {
+ Type *type;
+ Object *dtor;
+ ENode *expr;
+
+ for (; ivars; ivars = ivars->next) {
+ type = ivars->type;
+
+ if (IS_TYPE_ARRAY(type)) {
+ while (IS_TYPE_ARRAY(type))
+ type = TPTR_TARGET(type);
+
+ if (IS_TYPE_CLASS(type) && (dtor = CClass_Destructor(TYPE_CLASS(type)))) {
+ dtor = CABI_GetDestructorObject(dtor, 1);
+ stmt = CABI_DestroyMembers(stmt, ivars->next, tclass);
+ expr = create_objectrefnode(dtor);
+ expr->flags |= ENODE_FLAG_80;
+
+ stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+ stmt->expr = funccallexpr(
+ darr_func,
+ CABI_MakeThisExpr(tclass, ivars->offset),
+ expr,
+ intconstnode(TYPE(&stsignedlong), type->size),
+ intconstnode(TYPE(&stsignedlong), ivars->type->size / type->size)
+ );
+ return stmt;
+ }
+ } else {
+ if (IS_TYPE_CLASS(type) && (dtor = CClass_Destructor(TYPE_CLASS(type)))) {
+ stmt = CABI_DestroyMembers(stmt, ivars->next, tclass);
+
+ stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+ stmt->expr = CABI_DestroyObject(
+ dtor,
+ CABI_MakeThisExpr(tclass, ivars->offset),
+ CABIDestroy1,
+ 1,
+ 0
+ );
+ return stmt;
+ }
+ }
+ }
+
+ return stmt;
+}
+
+static Statement *CABI_DestroyBases(Statement *stmt, ClassList *bases) {
+ ClassList *base;
+ Object *dtor;
+ SInt32 count;
+ SInt32 i;
+
+ for (base = bases, count = 0; base; base = base->next)
+ count++;
+
+ while (count > 0) {
+ base = bases;
+ for (i = 1; i < count; i++)
+ base = base->next;
+
+ if (!base->is_virtual && (dtor = CClass_Destructor(base->base))) {
+ stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+ stmt->expr = CABI_DestroyObject(
+ dtor,
+ CABI_MakeThisExpr(NULL, base->offset),
+ CABIDestroy0,
+ 1,
+ 0);
+ }
+
+ count--;
+ }
+
+ return stmt;
+}
+
+static Statement *CABI_DestroyVBases(Statement *stmt, VClassList *vbases) {
+ Object *dtor;
+
+ for (; vbases; vbases = vbases->next) {
+ if ((dtor = CClass_Destructor(vbases->base))) {
+ stmt = CABI_DestroyVBases(stmt, vbases->next);
+ stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+ stmt->expr = CABI_DestroyObject(
+ dtor,
+ CABI_MakeThisExpr(NULL, vbases->offset),
+ CABIDestroy0,
+ 1,
+ 0);
+ break;
+ }
+ }
+
+ return stmt;
+}
+
+void CABI_TransDestructor(Object *obj1, Object *obj2, Statement *stmt, TypeClass *tclass, CABIDestroyMode mode) {
+ CLabel *label2;
+ Boolean flag29;
+ CLabel *label;
+ Statement *scan;
+ Boolean flag25;
+ Boolean flag24;
+ Boolean flag23;
+ CLabel *label3;
+ Object *dealloc;
+ Boolean deallocFlag;
+
+ if (tclass->sominfo) {
+ flag24 = 0;
+ flag25 = 0;
+ flag29 = 0;
+ flag23 = 1;
+ } else {
+ flag24 = 1;
+ flag23 = 1;
+ flag25 = 1;
+ flag29 = 1;
+ }
+
+ label = newlabel();
+
+ for (scan = stmt; scan; scan = scan->next) {
+ if (scan->type == ST_RETURN) {
+ CError_ASSERT(2329, !scan->expr);
+ scan->type = ST_GOTO;
+ scan->label = label;
+ }
+
+ if (scan->next && scan->next->type == ST_RETURN && !scan->next->next) {
+ CError_ASSERT(2334, !scan->next->expr);
+ scan->next = NULL;
+ break;
+ }
+ }
+
+ scan = stmt;
+
+ if (flag29) {
+ label2 = newlabel();
+ scan = CFunc_InsertStatement(ST_IFNGOTO, scan);
+ scan->expr = CABI_MakeThisExpr(NULL, 0);
+ scan->label = label2;
+ }
+
+ if (flag25 && tclass->vtable && tclass->vtable->object && tclass->vtable->owner == tclass) {
+ cabi_pathroot.next = NULL;
+ cabi_pathroot.type = TYPE(tclass);
+ cabi_pathcur = &cabi_pathroot;
+ trans_vtboffsets = NULL;
+ scan = CABI_InitVTablePtrs(scan, tclass->vtable->object, tclass, tclass, 0, 0);
+ }
+
+ if (!tclass->sominfo && (tclass->flags & CLASS_FLAGS_8000))
+ CABI_InitVBaseCtorOffsets(scan, tclass);
+
+ scan = stmt;
+ while (scan->next)
+ scan = scan->next;
+
+ scan = CFunc_InsertStatement(ST_LABEL, scan);
+ scan->label = label;
+ scan->dobjstack = NULL;
+ label->stmt = scan;
+
+ if (flag23 && !(tclass->flags & CLASS_FLAGS_1))
+ scan = CABI_DestroyMembers(scan, tclass->ivars, tclass);
+
+ if (flag25 && tclass->bases)
+ scan = CABI_DestroyBases(scan, tclass->bases);
+
+ if (flag24 && (tclass->flags & CLASS_FLAGS_20)) {
+ label3 = newlabel();
+ scan = CFunc_InsertStatement(ST_IFNGOTO, scan);
+ scan->expr = CABI_MakeVArgExpr();
+ scan->label = label3;
+
+ scan = CABI_DestroyVBases(scan, tclass->vbases);
+
+ scan = CFunc_InsertStatement(ST_LABEL, scan);
+ scan->label = label3;
+ label3->stmt = scan;
+ }
+
+ if (flag29) {
+ scan = CFunc_InsertStatement(ST_IFGOTO, scan);
+ scan->expr = CExpr_New_ELESSEQU_Node(CABI_MakeVArgExpr(), intconstnode(TYPE(&stsignedshort), 0));
+ scan->label = label2;
+
+ scan = CFunc_InsertStatement(ST_EXPRESSION, scan);
+ dealloc = CParser_FindDeallocationObject(TYPE(tclass), NULL, 0, 0, &deallocFlag);
+ if (deallocFlag) {
+ scan->expr = funccallexpr(
+ dealloc,
+ CABI_MakeThisExpr(NULL, 0),
+ intconstnode(CABI_GetSizeTType(), tclass->size),
+ NULL,
+ NULL);
+ } else {
+ scan->expr = funccallexpr(dealloc, CABI_MakeThisExpr(NULL, 0), NULL, NULL, NULL);
+ }
+
+ scan = CFunc_InsertStatement(ST_LABEL, scan);
+ scan->label = label2;
+ label2->stmt = scan;
+ }
+
+ scan = CFunc_InsertStatement(ST_RETURN, scan);
+ if (tclass->sominfo)
+ scan->expr = NULL;
+ else
+ scan->expr = CABI_MakeThisExpr(NULL, 0);
+}
+
+void CABI_MakeDefaultDestructor(TypeClass *tclass, Object *func) {
+ Boolean saveDebugInfo;
+ CScopeSave savedScope;
+ Statement firstStmt;
+ Statement returnStmt;
+
+ if (anyerrors || func->access == ACCESSNONE)
+ return;
+
+ CABI_ApplyClassFlags(func, tclass->eflags, 0);
+
+ CScope_SetFunctionScope(func, &savedScope);
+
+ CFunc_FuncGenSetup(&firstStmt, func);
+
+ saveDebugInfo = copts.isGeneratingDebugInfo;
+ copts.isGeneratingDebugInfo = 0;
+
+ CFunc_SetupNewFuncArgs(func, TYPE_FUNC(func->type)->args);
+
+ firstStmt.next = &returnStmt;
+
+ memclrw(&returnStmt, sizeof(Statement));
+ returnStmt.type = ST_RETURN;
+
+ CFunc_CodeCleanup(&firstStmt);
+
+ CABI_TransDestructor(func, func, &firstStmt, tclass, CABIDestroy0);
+
+ CFunc_Gen(&firstStmt, func, 0);
+
+ CScope_RestoreScope(&savedScope);
+ copts.isGeneratingDebugInfo = saveDebugInfo;
+}
+
+static void CABI_CreateLayeredDestructor(TypeClass *tclass, Object *obj1, Object *func, CABIDestroyMode mode) {
+ Boolean saveDebugInfo;
+ CScopeSave savedScope;
+ Statement firstStmt;
+ Statement returnStmt;
+
+ CError_FATAL(2524);
+
+ CScope_SetFunctionScope(func, &savedScope);
+
+ CFunc_FuncGenSetup(&firstStmt, func);
+
+ saveDebugInfo = copts.isGeneratingDebugInfo;
+ copts.isGeneratingDebugInfo = 0;
+
+ CFunc_SetupNewFuncArgs(func, TYPE_FUNC(func->type)->args);
+
+ firstStmt.next = &returnStmt;
+
+ memclrw(&returnStmt, sizeof(Statement));
+ returnStmt.type = ST_RETURN;
+
+ CFunc_CodeCleanup(&firstStmt);
+
+ CABI_TransDestructor(obj1, func, &firstStmt, tclass, mode);
+
+ CFunc_Gen(&firstStmt, func, 0);
+
+ CScope_RestoreScope(&savedScope);
+ copts.isGeneratingDebugInfo = saveDebugInfo;
+}
+
+void CABI_MakeLayeredDestructor(TypeClass *tclass, Object *func) {
+ Object *dtor;
+ CABIDestroyMode mode;
+
+ CError_FATAL(2557);
+
+ if (anyerrors || func->access == ACCESSNONE)
+ return;
+
+ if ((dtor = CClass_Destructor(tclass))) {
+ if (CABI_GetDestructorObject(dtor, CABIDestroy0) == func)
+ mode = CABIDestroy0;
+ else if (CABI_GetDestructorObject(dtor, CABIDestroy2) == func)
+ mode = CABIDestroy2;
+ else if (CABI_GetDestructorObject(dtor, CABIDestroy3) == func)
+ mode = CABIDestroy3;
+ else if (CABI_GetDestructorObject(dtor, CABIDestroy1) == func)
+ mode = CABIDestroy1;
+ else
+ CError_FATAL(2567);
+ }
+
+ CABI_CreateLayeredDestructor(tclass, dtor, func, mode);
+}
+
+Object *CABI_GetDestructorObject(Object *obj, CABIDestroyMode mode) {
return obj;
}
-static void CABI_AddLayeredDestructor() {}
-void CABI_AddLayeredDestructors(TypeClass *tclass) {}
+static void CABI_AddLayeredDestructor(TypeClass *tclass, Object *dtor, HashNameNode *name, Boolean is_virtual) {
+ Object *func;
+
+ CError_FATAL(2667);
+
+ func = CParser_NewFunctionObject(NULL);
+ func->nspace = dtor->nspace;
+ func->name = name;
+ func->type = TYPE(CDecl_MakeDefaultDtorType(tclass, is_virtual));
+ func->qual = Q_20000 | Q_80000;
+ func->qual |= Q_INLINE;
+ CABI_ApplyClassFlags(func, tclass->eflags, 1);
+
+ CError_ASSERT(2678, IS_TYPE_FUNC(func->type));
+ TYPE_FUNC(func->type)->flags |= FUNC_FLAGS_100;
+
+ if (dtor->datatype == DVFUNC) {
+ func->datatype = DVFUNC;
+ CMangler_GetLinkName(func);
+ func->datatype = DFUNC;
+ }
-ENode *CABI_DestroyObject(Object *dtor, ENode *objexpr, UInt8 mode, Boolean flag1, Boolean flag2) {}
+ CScope_AddObject(func->nspace, func->name, OBJ_BASE(func));
+}
+
+void CABI_AddLayeredDestructors(TypeClass *tclass) {
+ Object *dtor;
+
+ CError_FATAL(2707);
+
+ if ((dtor = CClass_Destructor(tclass))) {
+ CABI_AddLayeredDestructor(tclass, dtor, CMangler_DeleteDtorName(), 1);
+ CABI_AddLayeredDestructor(tclass, dtor, CMangler_SDeleteDtorName(), 1);
+ if (tclass->vbases)
+ CABI_AddLayeredDestructor(tclass, dtor, CMangler_VBaseDtorName(), 0);
+ }
+}
+
+ENode *CABI_DestroyObject(Object *dtor, ENode *objexpr, CABIDestroyMode mode, Boolean flag1, Boolean flag2) {
+ ENode *expr;
+ short arg;
+ ENodeList *list;
+
+ switch (mode) {
+ case CABIDestroy2:
+ case CABIDestroy3:
+ if (flag2)
+ arg = 1;
+ else
+ arg = -1;
+ break;
+ case CABIDestroy1:
+ arg = -1;
+ break;
+ case CABIDestroy0:
+ arg = 0;
+ break;
+ default:
+ CError_FATAL(2786);
+ }
+
+ expr = lalloc(sizeof(ENode));
+ expr->type = EFUNCCALL;
+ expr->cost = 200;
+ expr->flags = 0;
+ expr->rtype = &stvoid;
+ expr->data.funccall.funcref = create_objectrefnode(dtor);
+ if (flag1)
+ expr->data.funccall.funcref->flags |= ENODE_FLAG_80;
+ expr->data.funccall.functype = TYPE_FUNC(dtor->type);
+ dtor->flags |= OBJECT_FLAGS_UNUSED;
+
+ list = lalloc(sizeof(ENodeList));
+ list->node = objexpr;
+ expr->data.funccall.args = list;
+
+ list->next = lalloc(sizeof(ENodeList));
+ list = list->next;
+ list->next = NULL;
+ list->node = intconstnode(TYPE(&stsignedshort), arg);
+
+ return expr;
+}
diff --git a/compiler_and_linker/unsorted/CClass.c b/compiler_and_linker/unsorted/CClass.c
index 0d2091b..961d99b 100644
--- a/compiler_and_linker/unsorted/CClass.c
+++ b/compiler_and_linker/unsorted/CClass.c
@@ -1,12 +1,24 @@
#include "compiler/CClass.h"
+#include "compiler/CABI.h"
+#include "compiler/CDecl.h"
#include "compiler/CError.h"
+#include "compiler/CExpr.h"
+#include "compiler/CInit.h"
#include "compiler/CInline.h"
+#include "compiler/CMachine.h"
#include "compiler/CMangler.h"
+#include "compiler/CObjC.h"
#include "compiler/CParser.h"
+#include "compiler/CRTTI.h"
+#include "compiler/CSOM.h"
#include "compiler/CompilerTools.h"
#include "compiler/CodeGen.h"
#include "compiler/objects.h"
+#include "compiler/scopes.h"
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
typedef struct OVClassBase {
struct OVClassBase *next;
struct OVClass *ovclass;
@@ -38,16 +50,19 @@ typedef struct ThunkList {
SInt32 b;
SInt32 c;
} ThunkList;
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
static TypeClass *main_class;
static ThunkList *cclass_thunklist;
static TypeClass *cclass_isbase_mostderived;
-static void *cclass_isbase_foundoffset; // TODO type
+static SInt32 cclass_isbase_foundoffset;
static Boolean cclass_isambigbase;
static short cclass_founddepth;
-static void *vtable_object_data; // TODO type
-static void *vtable_data_size; // TODO type
-static VTableObjectLink *vtable_object_links;
+static char *vtable_object_data;
+static SInt32 vtable_data_size;
+static OLinkList *vtable_object_links;
static TypeClass *cclass_vbase;
static OVClass *cclass_ovbase;
static OVClass *cclass_root;
@@ -60,13 +75,15 @@ static TypeClass *cclass_dominator_oclass;
static SInt32 cclass_dominator_ooffset;
static Object *cclass_dominator_eobject;
-void CClass_Init(void) {}
+void CClass_Init(void) {
+ cclass_thunklist = NULL;
+}
void CClass_GenThunks(void) {
ThunkList *list;
for (list = cclass_thunklist; list; list = list->next) {
- list->obj->flags |= OBJECT_FLAGS_4;
+ list->thunkobj->flags |= OBJECT_FLAGS_4;
CodeGen_GenVDispatchThunk(list->thunkobj, list->obj, list->a, list->b, list->c);
}
}
@@ -100,76 +117,2196 @@ static Object *CClass_ThunkObject(Object *obj, SInt32 a, SInt32 b, SInt32 c) {
return thunkobj;
}
-static Boolean CClass_IsZeroOffsetClass(TypeClass *a, TypeClass *b) {}
-static UInt8 CClass_IsCovariantResult(Type *a, UInt32 qualA, Type *b, UInt32 qualB) {}
-UInt8 CClass_GetOverrideKind(TypeFunc *a, TypeFunc *b, Boolean errorflag) {}
-Boolean CClass_IsEmpty(TypeClass *tclass) {}
-Boolean CClass_IsNonStaticMemberFunc(TypeMethod *tmethod) {}
-Object *CClass_DefaultConstructor(TypeClass *tclass) {}
-Object *CClass_DummyDefaultConstructor(TypeClass *tclass) {}
-ENode *CClass_DefaultConstructorCall(TypeClass *a, TypeClass *b, ENode *expr, SInt32 unkshortparam, Boolean flag1, Boolean flag2, Boolean *errorflag) {}
-Object *CClass_AssignmentOperator(TypeClass *tclass) {}
-Object *CClass_CopyConstructor(TypeClass *tclass) {}
-NameSpaceObjectList *CClass_MemberObject(TypeClass *tclass, HashNameNode *name) {}
-NameSpaceObjectList *CClass_Constructor(TypeClass *tclass) {}
-Object *CClass_Destructor(TypeClass *tclass) {}
-Boolean CClass_IsConstructor(Object *obj) {}
-Boolean CClass_IsDestructor(Object *obj) {}
-Boolean CClass_IsPODClass(TypeClass *tclass) {}
-Boolean CClass_IsTrivialCopyClass(TypeClass *tclass) {}
-Boolean CClass_IsTrivialCopyAssignClass(TypeClass *tclass) {}
-Boolean CClass_ReferenceArgument(TypeClass *tclass) {}
-BClassList *CClass_GetPathCopy(BClassList *path, Boolean is_global) {}
-BClassList *CClass_AppendPath(BClassList *a, BClassList *b) {}
-static AccessType CClass_GetPathAccess(BClassList *path) {}
-Boolean CClass_IsMoreAccessiblePath(BClassList *path1, BClassList *path2) {}
-static BClassList *CClass_GetBasePathRec(TypeClass *a, TypeClass *b, SInt32 offset, short depth) {}
-BClassList *CClass_GetBasePath(TypeClass *a, TypeClass *b, short *founddepth, Boolean *isambigbase) {}
-Boolean CClass_IsBaseClass(TypeClass *a, TypeClass *b, short *founddepth, Boolean pathcheckflag, Boolean ambigerrorflag) {}
-TypeClass *CClass_GetQualifiedClass(void) {}
-ENode *CClass_AccessPathCast(BClassList *path, ENode *expr, Boolean flag) {}
-ENode *CClass_ClassPointerCast(ENode *expr, TypeClass *a, TypeClass *b, Boolean typconflag, Boolean ambigerrorflag, Boolean pathcheckflag) {}
-ENode *CClass_DirectBasePointerCast(ENode *expr, TypeClass *a, TypeClass *b) {}
-SInt32 CClass_GetPathOffset(BClassList *path) {}
-Boolean CClass_ClassDominates(TypeClass *a, TypeClass *b) {}
-SInt32 CClass_VirtualBaseOffset(TypeClass *a, TypeClass *b) {}
-SInt32 CClass_VirtualBaseVTableOffset(TypeClass *a, TypeClass *b) {}
-SInt32 CClass_GetMemberOffset(TypeClass *tclass, HashNameNode *name, ObjMemberVar **obj) {}
-Boolean CClass_OverridesBaseMember(TypeClass *tclass, HashNameNode *name, Object *obj) {}
-static OVClass *CClass_FindOVClass(OVClass *ovclass, TypeClass *tclass, SInt32 offset) {}
-static OVClass *CClass_BuildOVClassTree(OVClass *root, TypeClass *tclass, SInt32 offset, SInt32 voffset) {}
-static Boolean CClass_IsBaseOf(OVClass *a, OVClass *b) {}
-static void CClass_FindOVFunc(OVClass *a, OVClass *b, OVFunc *func) {}
-static TypeList *CClass_GetCoVariantClassList(TypeList *list, TypeClass *tclass, Object *func, Boolean flag) {}
-static TypeMethod *CClass_GetCovariantType(TypeMethod *tmethod, Type *type) {}
-static Object *CClass_FindCovariantFunction(Object *func, Type *type) {}
-static ObjectList *CClass_DeclareCovariantFuncs(ObjectList *list, Object *func, TypeClass *tclass) {}
-void CClass_DefineCovariantFuncs(Object *method, CI_FuncData *ifuncdata) {}
-static void CClass_OverrideOVClassTree(OVClass *ovclass) {}
-static void CClass_AllocVTableRec(OVClass *ovclass) {}
-static Object *CClass_CheckClass(OVClass *ovclass, Boolean errorflag) {}
-static void CClass_AllocVTable(TypeClass *tclass) {}
-static Object *CClass_CheckVirtuals(TypeClass *tclass) {}
-static void CClass_CheckVirtualBaseOverrides(OVClass *a, OVClass *b, Boolean flag) {}
-static void CClass_CheckHideVirtual(OVClass *a, OVClass *b) {}
-void CClass_CheckOverrides(TypeClass *tclass) {}
-static void CClass_FindDominator(TypeClass *tclass1, SInt32 offset1, Object *object1, TypeClass *tclass2, SInt32 offset2, TypeClass *base) {}
-static void CClass_ConstructVTable(TypeClass *tclass, SInt32 voffset, SInt32 offset, TypeClass *base) {}
-void CClass_ClassDefaultFuncAction(TypeClass *tclass) {}
-void CClass_ClassAction(TypeClass *tclass) {}
-void CClass_MakeStaticActionClass(TypeClass *tclass) {}
-Object *CClass_CheckPures(TypeClass *tclass) {}
-void CClass_MemberDef(Object *obj, TypeClass *tclass) {}
-Object *CClass_ThisSelfObject(void) {}
-ENode *CClass_CreateThisSelfExpr(void) {}
-static Boolean CClass_BaseMemberAccess(BClassList *path, AccessType access) {}
-static Boolean CClass_CanAccess(BClassList *path, AccessType access) {}
-void CClass_CheckPathAccess(BClassList *path, Object *obj, AccessType access) {}
-static BClassList *CClass_PathCleanup(BClassList *path, TypeClass *tclass) {}
-void CClass_CheckStaticAccess(BClassList *path, TypeClass *tclass, AccessType access) {}
-void CClass_CheckObjectAccess(BClassList *path, Object *obj) {}
-void CClass_CheckEnumAccess(BClassList *path, ObjEnumConst *objec) {}
-static Type *CClass_PointerTypeCopy(Type *type) {}
-Type *CClass_CombineClassAccessQualifiers(Type *type, UInt32 qual1, UInt32 qual2, UInt32 *outflags) {}
-static void CClass_OptimizeBitFieldAccess(Type **type, SInt32 *offset) {}
-ENode *CClass_AccessMember(ENode *classexpr, Type *type, UInt32 qual, SInt32 offset) {}
+static Boolean CClass_IsZeroOffsetClass(TypeClass *a, TypeClass *b) {
+ while (1) {
+ if (a == b)
+ return 1;
+
+ if (!a->bases || a->bases->is_virtual)
+ return 0;
+
+ a = a->bases->base;
+ }
+}
+
+static UInt8 CClass_IsCovariantResult(Type *a, UInt32 qualA, Type *b, UInt32 qualB, Boolean errorflag) {
+ TypeClass *tclassA;
+ TypeClass *tclassB;
+
+ if (
+ IS_TYPE_POINTER_ONLY(a) &&
+ IS_TYPE_POINTER_ONLY(b) &&
+ TPTR_QUAL(a) == TPTR_QUAL(b) &&
+ !CParser_IsMoreCVQualified(qualB, qualA) &&
+ IS_TYPE_CLASS(TPTR_TARGET(a)) &&
+ IS_TYPE_CLASS(TPTR_TARGET(b))
+ )
+ {
+ tclassA = TYPE_CLASS(TPTR_TARGET(a));
+ tclassB = TYPE_CLASS(TPTR_TARGET(b));
+ if (tclassA == tclassB || CClass_IsBaseClass(tclassB, tclassA, NULL, errorflag, errorflag)) {
+ if (!CClass_IsZeroOffsetClass(tclassB, tclassA))
+ return 2;
+ else
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+UInt8 CClass_GetOverrideKind(TypeFunc *a, TypeFunc *b, Boolean errorflag) {
+ if (!a->args || !b->args)
+ return 0;
+
+ if (
+ (a->flags & (FUNC_FLAGS_PASCAL | FUNC_FLAGS_F0000000)) != (b->flags & (FUNC_FLAGS_PASCAL | FUNC_FLAGS_F0000000)) ||
+ !is_arglistsame(a->args->next, b->args->next) ||
+ a->args->qual != b->args->qual
+ )
+ return 0;
+
+ if (!is_typesame(a->functype, b->functype)) {
+ switch (CClass_IsCovariantResult(a->functype, a->qual, b->functype, b->qual, errorflag)) {
+ case 0:
+ if (errorflag)
+ CError_Error(CErrorStr227);
+ return 0;
+ case 1:
+ return 1;
+ case 2:
+ return 2;
+ default:
+ CError_FATAL(225);
+ }
+ }
+
+ return 1;
+}
+
+Boolean CClass_IsEmpty(TypeClass *tclass) {
+ ClassList *base;
+
+ if (tclass->ivars)
+ return 0;
+
+ for (base = tclass->bases; base; base = base->next) {
+ if (!CClass_IsEmpty(base->base))
+ return 0;
+ }
+
+ return 1;
+}
+
+Boolean CClass_IsNonStaticMemberFunc(TypeFunc *tfunc) {
+ return IS_TYPEFUNC_NONSTATIC_METHOD(tfunc) || (tfunc->flags & FUNC_FLAGS_80);
+}
+
+Object *CClass_DefaultConstructor(TypeClass *tclass) {
+ NameSpaceObjectList *nsol;
+ Object *object;
+
+ for (nsol = CScope_FindName(tclass->nspace, constructor_name_node); nsol; nsol = nsol->next) {
+ object = OBJECT(nsol->object);
+ if (object->otype == OT_OBJECT && IS_TYPE_FUNC(object->type)) {
+ if ((tclass->flags & CLASS_FLAGS_20) && !tclass->sominfo) {
+ if (TYPE_FUNC(object->type)->args->next && !TYPE_FUNC(object->type)->args->next->next)
+ return object;
+ } else {
+ if (!TYPE_FUNC(object->type)->args->next)
+ return object;
+ }
+ }
+ }
+
+ return NULL;
+}
+
+Object *CClass_DummyDefaultConstructor(TypeClass *tclass) {
+ Object *ctor;
+ FuncArg *args;
+ NameSpaceObjectList *nsol;
+ HashNameNode *name;
+ TypeMethod *tmethod;
+ Object *object;
+ ObjectList list;
+
+ ctor = NULL;
+
+ for (nsol = CScope_FindName(tclass->nspace, constructor_name_node); nsol; nsol = nsol->next) {
+ object = OBJECT(nsol->object);
+ if (object->otype == OT_OBJECT && IS_TYPE_FUNC(object->type)) {
+ CError_ASSERT(305, args = TYPE_FUNC(object->type)->args);
+ args = args->next;
+ if ((tclass->flags & CLASS_FLAGS_20) && !tclass->sominfo) {
+ CError_ASSERT(309, args);
+ args = args->next;
+ }
+ CError_ASSERT(312, args);
+
+ if (args->dexpr) {
+ if (ctor) {
+ list.next = NULL;
+ list.object = object;
+ CError_OverloadedFunctionError(ctor, &list);
+ break;
+ }
+ ctor = object;
+ }
+ }
+ }
+
+ if (!ctor) {
+ CError_Error(CErrorStr203);
+ return NULL;
+ }
+
+ name = GetHashNameNodeExport("__defctor");
+ if ((nsol = CScope_FindName(tclass->nspace, name))) {
+ CError_ASSERT(339, nsol->object->otype == OT_OBJECT && IS_TYPE_FUNC(OBJECT(nsol->object)->type));
+ return OBJECT(nsol->object);
+ }
+
+ tmethod = galloc(sizeof(TypeMethod));
+ memclrw(tmethod, sizeof(TypeMethod));
+
+ tmethod->type = TYPEFUNC;
+ tmethod->functype = TYPE(&void_ptr);
+ tmethod->flags = FUNC_FLAGS_METHOD;
+ tmethod->theclass = tclass;
+ CDecl_SetFuncFlags(TYPE_FUNC(tmethod), 0);
+
+ if ((tclass->flags & CLASS_FLAGS_20) && !tclass->sominfo)
+ CDecl_AddArgument(TYPE_FUNC(tmethod), TYPE(&stsignedshort));
+
+ CDecl_AddThisPointerArgument(TYPE_FUNC(tmethod), tclass);
+
+ object = CParser_NewCompilerDefFunctionObject();
+ object->type = TYPE(tmethod);
+ object->qual = Q_INLINE | Q_80000;
+ object->nspace = tclass->nspace;
+ object->name = name;
+
+ CScope_AddObject(tclass->nspace, name, OBJ_BASE(object));
+ CParser_RegisterDummyCtorFunction(object, ctor);
+ return object;
+}
+
+ENode *CClass_DefaultConstructorCall(TypeClass *tclass, TypeClass *b, ENode *objexpr, SInt32 varg, Boolean flag1, Boolean flag2, Boolean *errorflag) {
+ NameSpaceObjectList *nsol;
+ Object *ctor;
+ Object *object;
+ FuncArg *args;
+ ENodeList *argexprs;
+ ENode *expr;
+ BClassList *path;
+ BClassList list1;
+ ObjectList objlist;
+ BClassList list2;
+ short founddepth;
+ Boolean isambigbase;
+
+ *errorflag = 0;
+
+ if (!(nsol = CScope_FindName(tclass->nspace, constructor_name_node)))
+ return NULL;
+
+ ctor = NULL;
+ do {
+ object = OBJECT(nsol->object);
+ if (object->otype == OT_OBJECT && IS_TYPE_FUNC(object->type)) {
+ CError_ASSERT(397, args = TYPE_FUNC(object->type)->args);
+
+ args = args->next;
+
+ if ((tclass->flags & CLASS_FLAGS_20) && !tclass->sominfo) {
+ CError_ASSERT(401, args);
+ args = args->next;
+ }
+
+ if (!args || args->dexpr) {
+ if (ctor) {
+ objlist.next = NULL;
+ objlist.object = object;
+ CError_OverloadedFunctionError(ctor, &objlist);
+ break;
+ }
+ ctor = object;
+ }
+ }
+ } while ((nsol = nsol->next));
+
+ if (!ctor) {
+ *errorflag = 1;
+ return NULL;
+ }
+
+ if (flag1) {
+ if (b) {
+ if (flag2) {
+ if ((path = CClass_GetBasePath(b, tclass, &founddepth, &isambigbase)))
+ list1 = *path;
+ else
+ goto skipCheck;
+ } else {
+ list1.next = &list2;
+ list1.type = TYPE(b);
+ list2.next = NULL;
+ list2.type = TYPE(tclass);
+ }
+ } else {
+ list1.next = NULL;
+ list1.type = TYPE(tclass);
+ }
+ CClass_CheckPathAccess(&list1, ctor, ctor->access);
+ }
+
+skipCheck:
+ if ((tclass->flags & CLASS_FLAGS_20) && !tclass->sominfo) {
+ argexprs = lalloc(sizeof(ENodeList));
+ argexprs->next = NULL;
+ argexprs->node = intconstnode(TYPE(&stsignedshort), varg);
+ } else {
+ argexprs = NULL;
+ }
+
+ CError_ASSERT(471, IS_TYPE_POINTER_ONLY(objexpr->rtype));
+
+ objexpr = makemonadicnode(objexpr, EINDIRECT);
+ objexpr->rtype = TYPE(tclass);
+
+ list1.next = NULL;
+ list1.type = TYPE(tclass);
+
+ expr = CExpr_GenericFuncCall(
+ &list1,
+ objexpr,
+ 0,
+ ctor,
+ NULL,
+ NULL,
+ argexprs,
+ 0,
+ 0,
+ 0
+ );
+
+ if (ENODE_IS2(expr, EFUNCCALL, EFUNCCALLP))
+ expr->rtype = CDecl_NewPointerType(TYPE(tclass));
+
+ return expr;
+}
+
+Object *CClass_AssignmentOperator(TypeClass *tclass) {
+ NameSpaceObjectList *nsol;
+ Object *object;
+
+ for (nsol = CScope_FindName(tclass->nspace, asop_name_node); nsol; nsol = nsol->next) {
+ object = OBJECT(nsol->object);
+ if (
+ object->otype == OT_OBJECT &&
+ IS_TYPE_FUNC(object->type) &&
+ TYPE_FUNC(object->type)->args &&
+ TYPE_FUNC(object->type)->args->next &&
+ !TYPE_FUNC(object->type)->args->next->next
+ )
+ {
+ if (
+ IS_TYPE_CLASS(TYPE_FUNC(object->type)->args->next->type) &&
+ TYPE_CLASS(TYPE_FUNC(object->type)->args->next->type) == tclass
+ )
+ return object;
+
+ if (
+ IS_TYPE_REFERENCE(TYPE_FUNC(object->type)->args->next->type) &&
+ TPTR_TARGET(TYPE_FUNC(object->type)->args->next->type) == TYPE(tclass)
+ )
+ return object;
+ }
+ }
+
+ return NULL;
+}
+
+Object *CClass_CopyConstructor(TypeClass *tclass) {
+ NameSpaceObjectList *nsol;
+ Object *object;
+ FuncArg *args;
+
+ if (tclass->sominfo)
+ return NULL;
+
+ for (nsol = CScope_FindName(tclass->nspace, constructor_name_node); nsol; nsol = nsol->next) {
+ object = OBJECT(nsol->object);
+ if (object->otype == OT_OBJECT && IS_TYPE_FUNC(object->type)) {
+ CError_ASSERT(532, args = TYPE_FUNC(object->type)->args);
+
+ args = args->next;
+
+ if (tclass->flags & CLASS_FLAGS_20) {
+ CError_ASSERT(536, args);
+ args = args->next;
+ }
+
+ if (
+ args &&
+ args != &elipsis &&
+ (!args->next || args->next->dexpr) &&
+ IS_TYPE_REFERENCE(args->type) &&
+ TPTR_TARGET(args->type) == TYPE(tclass)
+ )
+ return object;
+ }
+ }
+
+ return NULL;
+}
+
+NameSpaceObjectList *CClass_MemberObject(TypeClass *tclass, HashNameNode *name) {
+ NameSpaceObjectList *nsol;
+
+ if ((nsol = CScope_FindName(tclass->nspace, name)) && nsol->object->otype == OT_OBJECT)
+ return nsol;
+
+ return NULL;
+}
+
+NameSpaceObjectList *CClass_Constructor(TypeClass *tclass) {
+ NameSpaceObjectList *nsol;
+
+ if (
+ (nsol = CScope_FindName(tclass->nspace, constructor_name_node)) &&
+ nsol->object->otype == OT_OBJECT &&
+ IS_TYPE_FUNC(OBJECT(nsol->object)->type)
+ )
+ return nsol;
+
+ return NULL;
+}
+
+Object *CClass_Destructor(TypeClass *tclass) {
+ NameSpaceObjectList *nsol;
+
+ for (nsol = CScope_FindName(tclass->nspace, destructor_name_node); nsol; nsol = nsol->next) {
+ if (
+ nsol->object->otype == OT_OBJECT &&
+ IS_TYPE_FUNC(OBJECT(nsol->object)->type)
+ )
+ return OBJECT(nsol->object);
+ }
+
+ return NULL;
+}
+
+Boolean CClass_IsConstructor(Object *obj) {
+ return obj && IS_TYPE_FUNC(obj->type) && (TYPE_FUNC(obj->type)->flags & FUNC_FLAGS_1000);
+}
+
+Boolean CClass_IsDestructor(Object *obj) {
+ return obj && IS_TYPE_FUNC(obj->type) && (TYPE_FUNC(obj->type)->flags & FUNC_FLAGS_2000);
+}
+
+Boolean CClass_IsPODClass(TypeClass *tclass) {
+ NameSpaceObjectList *nsol;
+ Object *object;
+ ObjMemberVar *ivar;
+ Type *type;
+
+ if (tclass->vtable || tclass->bases || CClass_Destructor(tclass))
+ return 0;
+
+ for (nsol = CClass_Constructor(tclass); nsol; nsol = nsol->next) {
+ if (
+ nsol->object->otype == OT_OBJECT &&
+ IS_TYPE_FUNC(OBJECT(nsol->object)->type) &&
+ !(TYPE_FUNC(OBJECT(nsol->object)->type)->flags & FUNC_FLAGS_100)
+ )
+ return 0;
+ }
+
+ object = CClass_AssignmentOperator(tclass);
+ if (object && !(TYPE_FUNC(object->type)->flags & FUNC_FLAGS_100))
+ return 0;
+
+ for (ivar = tclass->ivars; ivar; ivar = ivar->next) {
+ if (ivar->access != ACCESSPUBLIC)
+ return 0;
+
+ type = ivar->type;
+ while (IS_TYPE_ARRAY(type))
+ type = TPTR_TARGET(type);
+
+ switch (type->type) {
+ case TYPECLASS:
+ if (!CClass_IsPODClass(TYPE_CLASS(type)))
+ return 0;
+ break;
+ case TYPEMEMBERPOINTER:
+ return 0;
+ case TYPEPOINTER:
+ if (TPTR_QUAL(type) & Q_REFERENCE)
+ return 0;
+ break;
+ }
+ }
+
+ return 1;
+}
+
+Boolean CClass_IsTrivialCopyClass(TypeClass *tclass) {
+ Object *object;
+ ClassList *base;
+ ObjMemberVar *ivar;
+ Type *type;
+
+ if (tclass->vtable || tclass->vbases || CClass_Destructor(tclass))
+ return 0;
+
+ object = CClass_CopyConstructor(tclass);
+ if (object && IS_TYPE_FUNC(object->type) && !(TYPE_FUNC(object->type)->flags & FUNC_FLAGS_100))
+ return 0;
+
+ for (base = tclass->bases; base; base = base->next) {
+ if (!CClass_IsTrivialCopyClass(base->base))
+ return 0;
+ }
+
+ for (ivar = tclass->ivars; ivar; ivar = ivar->next) {
+ type = ivar->type;
+ while (IS_TYPE_ARRAY(type))
+ type = TPTR_TARGET(type);
+
+ if (IS_TYPE_CLASS(type) && !CClass_IsTrivialCopyClass(TYPE_CLASS(type)))
+ return 0;
+ }
+
+ return 1;
+}
+
+Boolean CClass_IsTrivialCopyAssignClass(TypeClass *tclass) {
+ Object *object;
+ ObjMemberVar *ivar;
+ Type *type;
+
+ if (tclass->vtable || tclass->bases || CClass_Destructor(tclass))
+ return 0;
+
+ object = CClass_AssignmentOperator(tclass);
+ if (object && !(TYPE_FUNC(object->type)->flags & FUNC_FLAGS_100))
+ return 0;
+
+ for (ivar = tclass->ivars; ivar; ivar = ivar->next) {
+ type = ivar->type;
+ while (IS_TYPE_ARRAY(type))
+ type = TPTR_TARGET(type);
+
+ if (IS_TYPE_REFERENCE(type))
+ return 0;
+ if (CParser_IsConst(type, ivar->qual))
+ return 0;
+ if (IS_TYPE_CLASS(type) && !CClass_IsTrivialCopyAssignClass(TYPE_CLASS(type)))
+ return 0;
+ }
+
+ return 1;
+}
+
+Boolean CClass_ReferenceArgument(TypeClass *tclass) {
+ if ((tclass->flags & (CLASS_FLAGS_2 | CLASS_FLAGS_800)) == CLASS_FLAGS_800)
+ CDecl_CompleteType(TYPE(tclass));
+
+ if (copts.simple_class_byval)
+ return !CClass_IsTrivialCopyClass(tclass);
+
+ return CClass_Destructor(tclass) || CClass_CopyConstructor(tclass);
+}
+
+BClassList *CClass_GetPathCopy(BClassList *path, Boolean is_global) {
+ BClassList *last;
+ BClassList *copy;
+
+ if (!path)
+ return NULL;
+
+ copy = last = is_global ? galloc(sizeof(BClassList)) : lalloc(sizeof(BClassList));
+ last->next = path->next;
+ last->type = path->type;
+
+ while ((path = path->next)) {
+ last->next = is_global ? galloc(sizeof(BClassList)) : lalloc(sizeof(BClassList));
+ last = last->next;
+ last->next = path->next;
+ last->type = path->type;
+ }
+
+ return copy;
+}
+
+BClassList *CClass_AppendPath(BClassList *dest, BClassList *src) {
+ BClassList *last;
+
+ if (!(last = dest))
+ return src;
+
+ while (last->next)
+ last = last->next;
+
+ while (src && src->type == last->type)
+ src = src->next;
+
+ last->next = src;
+ return dest;
+}
+
+static AccessType CClass_GetPathAccess(BClassList *path) {
+ AccessType result;
+ ClassList *base;
+ TypeClass *tclass;
+
+ CError_ASSERT(930, path);
+
+ result = ACCESSPUBLIC;
+
+ while (1) {
+ tclass = TYPE_CLASS(path->type);
+ if (!(path = path->next))
+ break;
+
+ for (base = tclass->bases; base; base = base->next) {
+ if (base->base == TYPE_CLASS(path->type))
+ break;
+ }
+
+ CError_ASSERT(939, base);
+
+ switch (base->access) {
+ case ACCESSPUBLIC:
+ break;
+ case ACCESSPROTECTED:
+ if (result == ACCESSPUBLIC)
+ result = ACCESSPROTECTED;
+ break;
+ case ACCESSPRIVATE:
+ if (result == ACCESSPUBLIC || result == ACCESSPROTECTED)
+ result = ACCESSPRIVATE;
+ else
+ return ACCESSNONE;
+ break;
+ case ACCESSNONE:
+ return ACCESSNONE;
+ default:
+ CError_FATAL(960);
+ }
+ }
+
+ return result;
+}
+
+Boolean CClass_IsMoreAccessiblePath(BClassList *path1, BClassList *path2) {
+ switch (CClass_GetPathAccess(path2)) {
+ case ACCESSPUBLIC:
+ return 0;
+ case ACCESSNONE:
+ return 1;
+ default:
+ CError_FATAL(978);
+ case ACCESSPROTECTED:
+ switch (CClass_GetPathAccess(path1)) {
+ case ACCESSPUBLIC:
+ return 1;
+ case ACCESSPRIVATE:
+ case ACCESSPROTECTED:
+ case ACCESSNONE:
+ return 0;
+ default:
+ CError_FATAL(987);
+ }
+ case ACCESSPRIVATE:
+ switch (CClass_GetPathAccess(path1)) {
+ case ACCESSPUBLIC:
+ case ACCESSPROTECTED:
+ return 1;
+ case ACCESSPRIVATE:
+ case ACCESSNONE:
+ return 0;
+ default:
+ CError_FATAL(997);
+ }
+ }
+
+ return 0;
+}
+
+static BClassList *CClass_GetBasePathRec(TypeClass *a, TypeClass *b, SInt32 offset, short depth) {
+ ClassList *base;
+ BClassList *checkpath;
+ BClassList *bestpath;
+ BClassList *newpath;
+ SInt32 newOffset;
+
+ for (base = a->bases, bestpath = NULL; base; base = base->next) {
+ if (base->is_virtual)
+ newOffset = CClass_VirtualBaseOffset(cclass_isbase_mostderived, base->base);
+ else
+ newOffset = offset + base->offset;
+
+ if (base->base == b) {
+ if (cclass_founddepth && newOffset != cclass_isbase_foundoffset) {
+ cclass_isambigbase = 1;
+ return NULL;
+ }
+
+ cclass_isbase_foundoffset = newOffset;
+ cclass_founddepth = depth;
+
+ bestpath = lalloc(sizeof(BClassList));
+ bestpath->next = NULL;
+ bestpath->type = TYPE(b);
+ } else if ((checkpath = CClass_GetBasePathRec(base->base, b, newOffset, depth + 1))) {
+ newpath = lalloc(sizeof(BClassList));
+ newpath->next = checkpath;
+ newpath->type = TYPE(base->base);
+ if (!bestpath || CClass_IsMoreAccessiblePath(newpath, bestpath))
+ bestpath = newpath;
+ }
+ }
+
+ return bestpath;
+}
+
+BClassList *CClass_GetBasePath(TypeClass *a, TypeClass *b, short *founddepth, Boolean *isambigbase) {
+ BClassList *path;
+ BClassList *result;
+
+ if ((a->flags & (CLASS_FLAGS_2 | CLASS_FLAGS_800)) == CLASS_FLAGS_800)
+ CDecl_CompleteType(TYPE(a));
+ if ((b->flags & (CLASS_FLAGS_2 | CLASS_FLAGS_800)) == CLASS_FLAGS_800)
+ CDecl_CompleteType(TYPE(b));
+
+ cclass_founddepth = 0;
+ cclass_isbase_mostderived = a;
+ cclass_isbase_foundoffset = -1;
+ cclass_isambigbase = 0;
+
+ if ((path = CClass_GetBasePathRec(a, b, 0, 1))) {
+ *founddepth = cclass_founddepth;
+ *isambigbase = cclass_isambigbase;
+
+ result = lalloc(sizeof(BClassList));
+ result->next = path;
+ result->type = TYPE(a);
+ return result;
+ } else {
+ *isambigbase = 0;
+ return NULL;
+ }
+}
+
+Boolean CClass_IsBaseClass(TypeClass *a, TypeClass *b, short *founddepth, Boolean pathcheckflag, Boolean ambigerrorflag) {
+ BClassList *path;
+ short depth;
+ Boolean isambigbase;
+
+ if ((path = CClass_GetBasePath(a, b, &depth, &isambigbase))) {
+ if (isambigbase && ambigerrorflag)
+ CError_Error(CErrorStr188);
+
+ if (pathcheckflag)
+ CClass_CheckPathAccess(path, NULL, ACCESSPUBLIC);
+
+ if (founddepth)
+ *founddepth = depth;
+
+ return 1;
+ }
+
+ return 0;
+}
+
+TypeClass *CClass_GetQualifiedClass(void) {
+ DeclInfo di;
+
+ memclrw(&di, sizeof(di));
+ CParser_GetDeclSpecs(&di, 0);
+
+ if (IS_TYPE_CLASS(di.thetype))
+ return TYPE_CLASS(di.thetype);
+
+ return NULL;
+}
+
+ENode *CClass_AccessPathCast(BClassList *path, ENode *expr, Boolean reverse) {
+ ClassList *base;
+ SInt32 offset;
+
+ while (path && path->next) {
+ base = TYPE_CLASS(path->type)->bases;
+ while (1) {
+ if (base->base == TYPE_CLASS(path->next->type))
+ break;
+ CError_ASSERT(1157, base = base->next);
+ }
+
+ if (base->is_virtual) {
+ if (reverse) {
+ CError_Error(CErrorStr164);
+ break;
+ }
+
+ if (!base->base->sominfo) {
+ offset = base->offset;
+ if (offset && !canadd(expr, offset)) {
+ expr = makediadicnode(expr, intconstnode(TYPE(&stunsignedlong), offset), EADD);
+ optimizecomm(expr);
+ }
+
+ expr->rtype = CDecl_NewPointerType(CDecl_NewPointerType(TYPE(base->base)));
+ expr = makemonadicnode(expr, EINDIRECT);
+ expr->rtype = expr->data.monadic->rtype;
+ }
+ } else {
+ offset = base->offset;
+ if (offset) {
+ if (reverse)
+ offset = -offset;
+ if (!canadd(expr, offset)) {
+ expr = makediadicnode(expr, intconstnode(TYPE(&stunsignedlong), offset), EADD);
+ optimizecomm(expr);
+ }
+ }
+ }
+
+ path = path->next;
+ }
+
+ return expr;
+}
+
+ENode *CClass_ClassPointerCast(ENode *expr, TypeClass *a, TypeClass *b, Boolean typconflag, Boolean ambigerrorflag, Boolean pathcheckflag) {
+ BClassList *path;
+ Boolean reverse;
+ short depth;
+ Boolean isambigbase;
+
+ reverse = 0;
+
+ if (a != b) {
+ if (!(path = CClass_GetBasePath(a, b, &depth, &isambigbase))) {
+ CError_ASSERT(1216, typconflag);
+ if ((path = CClass_GetBasePath(b, a, &depth, &isambigbase))) {
+ reverse = 1;
+ goto doCast;
+ }
+ } else {
+ doCast:
+ if (isambigbase && ambigerrorflag)
+ CError_Error(CErrorStr188);
+ if (pathcheckflag)
+ CClass_CheckPathAccess(path, NULL, ACCESSPUBLIC);
+ if (!(a->flags & CLASS_FLAGS_10) && !b->sominfo)
+ expr = CClass_AccessPathCast(path, expr, reverse);
+ }
+ }
+
+ if (typconflag && ENODE_IS(expr, EINDIRECT) && IS_TYPE_POINTER_ONLY(expr->rtype))
+ expr = makemonadicnode(expr, ETYPCON);
+
+ return expr;
+}
+
+ENode *CClass_DirectBasePointerCast(ENode *expr, TypeClass *a, TypeClass *b) {
+ ClassList *base;
+ VClassList *vbase;
+ BClassList *path;
+ BClassList list1;
+ BClassList list2;
+ short depth;
+ Boolean isambigbase;
+
+ for (base = a->bases; base; base = base->next) {
+ if (base->base == b) {
+ list1.next = &list2;
+ list1.type = TYPE(a);
+ list2.next = NULL;
+ list2.type = TYPE(b);
+ return CClass_AccessPathCast(&list1, expr, 0);
+ }
+ }
+
+ for (vbase = a->vbases; vbase; vbase = vbase->next) {
+ if (vbase->base == b) {
+ CError_ASSERT(1273, path = CClass_GetBasePath(a, b, &depth, &isambigbase));
+ return CClass_AccessPathCast(path, expr, 0);
+ }
+ }
+
+ CError_FATAL(1277);
+ return expr;
+}
+
+SInt32 CClass_GetPathOffset(BClassList *path) {
+ SInt32 offset;
+ ClassList *base;
+
+ offset = 0;
+
+ while (path->next) {
+ if (path->type != path->next->type) {
+ for (base = TYPE_CLASS(path->type)->bases; base; base = base->next) {
+ if (base->base == TYPE_CLASS(path->next->type))
+ break;
+ }
+
+ if (!base) {
+ CError_Error(CErrorStr221);
+ return offset;
+ }
+ }
+
+ if (base->is_virtual)
+ return -1;
+ offset += base->offset;
+
+ path = path->next;
+ }
+
+ return offset;
+}
+
+Boolean CClass_ClassDominates(TypeClass *tclass, TypeClass *baseclass) {
+ ClassList *base;
+
+ for (base = tclass->bases; base; base = base->next) {
+ if (base->base == baseclass || CClass_ClassDominates(base->base, baseclass))
+ return 1;
+ }
+
+ return 0;
+}
+
+SInt32 CClass_VirtualBaseOffset(TypeClass *tclass, TypeClass *baseclass) {
+ VClassList *vbase;
+
+ for (vbase = tclass->vbases; vbase; vbase = vbase->next) {
+ if (vbase->base == baseclass)
+ return vbase->offset;
+ }
+
+ CError_FATAL(1342);
+ return 0;
+}
+
+SInt32 CClass_VirtualBaseVTableOffset(TypeClass *tclass, TypeClass *baseclass) {
+ VClassList *vbase;
+
+ for (vbase = tclass->vbases; vbase; vbase = vbase->next) {
+ if (vbase->base == baseclass)
+ return vbase->voffset;
+ }
+
+ CError_FATAL(1359);
+ return 0;
+}
+
+SInt32 CClass_GetMemberOffset(TypeClass *tclass, HashNameNode *name, ObjMemberVar **resultIvar) {
+ ObjMemberVar *ivar;
+ ClassList *base;
+ SInt32 offset;
+ SInt32 tmp;
+ Boolean foundflag;
+
+ for (ivar = tclass->ivars; ivar; ivar = ivar->next) {
+ if (ivar->name == name) {
+ if (resultIvar)
+ *resultIvar = ivar;
+ return ivar->offset;
+ }
+ }
+
+ for (base = tclass->bases, foundflag = 0; base; base = base->next) {
+ switch ((tmp = CClass_GetMemberOffset(base->base, name, resultIvar))) {
+ case -3:
+ case -2:
+ return tmp;
+ case -1:
+ break;
+ default:
+ if (base->is_virtual)
+ return -3;
+ if (foundflag)
+ return -2;
+ foundflag = 1;
+ offset = base->offset + tmp;
+ }
+ }
+
+ return foundflag ? offset : -1;
+}
+
+Boolean CClass_OverridesBaseMember(TypeClass *tclass, HashNameNode *name, Object *obj) {
+ NameSpaceObjectList *nsol;
+ ClassList *base;
+ Boolean result;
+
+ result = 0;
+ for (base = tclass->bases; base; base = base->next) {
+ if (base->base->vtable) {
+ for (nsol = CScope_FindName(base->base->nspace, name); nsol; nsol = nsol->next) {
+ if (
+ nsol->object->otype == OT_OBJECT &&
+ OBJECT(nsol->object)->datatype == DVFUNC &&
+ CClass_GetOverrideKind(TYPE_FUNC(OBJECT(nsol->object)->type), TYPE_FUNC(obj->type), 1)
+ )
+ result = 1;
+ }
+
+ if (CClass_OverridesBaseMember(base->base, name, obj))
+ result = 1;
+ }
+ }
+
+ return result;
+}
+
+static OVClass *CClass_FindOVClass(OVClass *ovclass, TypeClass *tclass, SInt32 offset) {
+ OVClassBase *ovbase;
+
+ if (ovclass->tclass == tclass && ovclass->offset == offset)
+ return ovclass;
+
+ for (ovbase = ovclass->bases; ovbase; ovbase = ovbase->next) {
+ if ((ovclass = CClass_FindOVClass(ovbase->ovclass, tclass, offset)))
+ return ovclass;
+ }
+
+ return NULL;
+}
+
+static OVClass *CClass_BuildOVClassTree(OVClass *root, TypeClass *tclass, SInt32 offset, SInt32 voffset) {
+ ClassList *base;
+ Object *object;
+ OVClass *tree;
+ OVFunc *ovfunc;
+ OVClassBase *ovbase;
+ SInt32 vboffset;
+ SInt32 vbvoffset;
+ CScopeObjectIterator iter;
+
+ tree = lalloc(sizeof(OVClass));
+ memclrw(tree, sizeof(OVClass));
+
+ tree->tclass = tclass;
+ tree->offset = offset;
+ tree->voffset = voffset;
+ if (!root)
+ root = tree;
+
+ CScope_InitObjectIterator(&iter, tclass->nspace);
+ while (1) {
+ if (!(object = OBJECT(CScope_NextObjectIteratorObject(&iter))))
+ break;
+
+ if (object->datatype == DVFUNC) {
+ ovfunc = lalloc(sizeof(OVFunc));
+ memclrw(ovfunc, sizeof(OVFunc));
+
+ ovfunc->next = tree->vfuncs;
+ ovfunc->obj = object;
+ tree->vfuncs = ovfunc;
+ }
+ }
+
+ for (base = tclass->bases; base; base = base->next) {
+ if (base->base->vtable || base->base->sominfo) {
+ ovbase = lalloc(sizeof(OVClassBase));
+ memclrw(ovbase, sizeof(OVClassBase));
+
+ if (base->is_virtual) {
+ vboffset = CClass_VirtualBaseOffset(main_class, base->base);
+ if (!(ovbase->ovclass = CClass_FindOVClass(root, base->base, vboffset))) {
+ vbvoffset = CClass_VirtualBaseVTableOffset(main_class, base->base);
+ ovbase->ovclass = CClass_BuildOVClassTree(root, base->base, vboffset, vbvoffset);
+ }
+ ovbase->is_virtual = 1;
+ } else {
+ ovbase->ovclass = CClass_BuildOVClassTree(
+ root,
+ base->base,
+ offset + base->offset,
+ voffset + base->voffset);
+ ovbase->is_virtual = 0;
+ }
+
+ ovbase->next = tree->bases;
+ tree->bases = ovbase;
+ }
+ }
+
+ return tree;
+}
+
+static Boolean CClass_IsBaseOf(OVClass *a, OVClass *b) {
+ OVClassBase *ovbase;
+
+ for (ovbase = b->bases; ovbase; ovbase = ovbase->next) {
+ if (
+ (ovbase->ovclass->tclass == a->tclass && ovbase->ovclass->offset == a->offset) ||
+ CClass_IsBaseOf(a, ovbase->ovclass)
+ )
+ {
+ if (!cclass_ovbase && ovbase->is_virtual)
+ cclass_ovbase = ovbase->ovclass;
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+static void CClass_FindOVFunc(OVClass *a, OVClass *b, OVFunc *func) {
+ OVFunc *scan;
+ OVClassBase *ovbase;
+ UInt8 overrideKind;
+
+ if (CClass_IsBaseOf(b, a)) {
+ for (scan = a->vfuncs; scan; scan = scan->next) {
+ if (
+ (func->obj->name == scan->obj->name) &&
+ (overrideKind = CClass_GetOverrideKind(TYPE_FUNC(func->obj->type), TYPE_FUNC(scan->obj->type), 0))
+ )
+ {
+ if (func->ovc8) {
+ if (func->ovc8->tclass == a->tclass || CClass_ClassDominates(func->ovc8->tclass, a->tclass))
+ return;
+ if (!CClass_ClassDominates(a->tclass, func->ovc8->tclass)) {
+ func->ovf10 = scan;
+ return;
+ }
+ }
+
+ if (a == cclass_root) {
+ TYPE_FUNC(scan->obj->type)->flags |= FUNC_FLAGS_20;
+ if (overrideKind == 2)
+ TYPE_FUNC(scan->obj->type)->flags |= FUNC_FLAGS_400000;
+ }
+
+ func->ovc8 = a;
+ func->ovfC = scan;
+ func->ovf10 = NULL;
+ return;
+ }
+ }
+
+ for (ovbase = a->bases; ovbase; ovbase = ovbase->next)
+ CClass_FindOVFunc(ovbase->ovclass, b, func);
+ }
+}
+
+static TypeList *CClass_GetCoVariantClassList(TypeList *list, TypeClass *tclass, Object *func, Boolean flag) {
+ Object *object;
+ TypeList *scan;
+ Type *type;
+ ClassList *base;
+ CScopeObjectIterator iter;
+
+ if (!flag) {
+ CScope_InitObjectIterator(&iter, tclass->nspace);
+ while (1) {
+ if (!(object = OBJECT(CScope_NextObjectIteratorObject(&iter))))
+ break;
+
+ if (
+ object->name == func->name &&
+ object->datatype == DVFUNC &&
+ CClass_GetOverrideKind(TYPE_FUNC(object->type), TYPE_FUNC(func->type), 0) == 2
+ )
+ {
+ CError_ASSERT(1686,
+ IS_TYPE_POINTER_ONLY(TYPE_FUNC(object->type)->functype) &&
+ IS_TYPE_CLASS(TPTR_TARGET(TYPE_FUNC(object->type)->functype)));
+
+ type = TPTR_TARGET(TYPE_FUNC(object->type)->functype);
+ for (scan = list; scan; scan = scan->next) {
+ if (scan->type == type)
+ break;
+ }
+
+ if (!scan) {
+ scan = lalloc(sizeof(TypeList));
+ scan->type = type;
+ scan->next = list;
+ list = scan;
+ }
+ }
+ }
+ }
+
+ for (base = tclass->bases; base; base = base->next) {
+ if (base->base->vtable)
+ list = CClass_GetCoVariantClassList(list, base->base, func, 0);
+ }
+
+ return list;
+}
+
+static TypeMethod *CClass_GetCovariantType(TypeMethod *tmethod, Type *type) {
+ TypePointer *tptr;
+ TypeMethod *result;
+
+ CError_ASSERT(1724,
+ IS_TYPE_METHOD(tmethod) &&
+ IS_TYPE_POINTER_ONLY(tmethod->functype));
+
+ tptr = galloc(sizeof(TypePointer));
+ *tptr = *TYPE_POINTER(tmethod->functype);
+ tptr->target = type;
+
+ result = galloc(sizeof(TypeMethod));
+ *result = *tmethod;
+ result->flags &= ~(FUNC_FLAGS_20 | FUNC_FLAGS_400000);
+ result->functype = TYPE(tptr);
+ return result;
+}
+
+static Object *CClass_FindCovariantFunction(Object *func, Type *type) {
+ NameSpaceObjectList *nsol;
+
+ nsol = CScope_FindName(
+ TYPE_METHOD(func->type)->theclass->nspace,
+ CMangler_GetCovariantFunctionName(func, type));
+
+ CError_ASSERT(1754, nsol && !nsol->next && nsol->object->otype == OT_OBJECT);
+
+ return OBJECT(nsol->object);
+}
+
+static ObjectList *CClass_DeclareCovariantFuncs(ObjectList *list, Object *func, TypeClass *tclass) {
+ Object *newfunc;
+ HashNameNode *name;
+ TypeList *types;
+ ObjectList *newlist;
+
+ for (types = CClass_GetCoVariantClassList(NULL, tclass, func, 1); types; types = types->next) {
+ name = CMangler_GetCovariantFunctionName(func, types->type);
+
+ newfunc = galloc(sizeof(Object));
+ memclrw(newfunc, sizeof(Object));
+
+ newfunc->otype = OT_OBJECT;
+ newfunc->datatype = DFUNC;
+ newfunc->section = func->section;
+ newfunc->nspace = func->nspace;
+ newfunc->name = name;
+ newfunc->type = TYPE(CClass_GetCovariantType(TYPE_METHOD(func->type), types->type));
+ newfunc->qual = func->qual & ~Q_INLINE;
+ newfunc->sclass = func->sclass;
+ newfunc->u.func.linkname = name;
+
+ newlist = lalloc(sizeof(ObjectList));
+ newlist->object = newfunc;
+ newlist->next = list;
+ list = newlist;
+ }
+
+ return list;
+}
+
+void CClass_DefineCovariantFuncs(Object *method, CI_FuncData *ifuncdata) {
+ NameSpace *nspace;
+ TypeList *types;
+ Object *covariantFunc;
+ Statement *stmt;
+ Type *tptr;
+ Statement firstStmt;
+
+ for (types = CClass_GetCoVariantClassList(NULL, TYPE_METHOD(method->type)->theclass, method, 1); types; types = types->next) {
+ covariantFunc = CClass_FindCovariantFunction(method, types->type);
+ tptr = CDecl_NewPointerType(types->type);
+
+ nspace = CFunc_FuncGenSetup(&firstStmt, covariantFunc);
+ CInline_UnpackIFunctionData(covariantFunc, ifuncdata, &firstStmt);
+
+ for (stmt = &firstStmt; stmt; stmt = stmt->next) {
+ if (stmt->type == ST_RETURN && stmt->expr)
+ stmt->expr = CExpr_AssignmentPromotion(stmt->expr, tptr, ENODE_QUALS(stmt->expr), 0);
+ }
+
+ CFunc_Gen(&firstStmt, covariantFunc, 0);
+ cscope_current = nspace->parent;
+ }
+}
+
+static void CClass_OverrideOVClassTree(OVClass *ovclass) {
+ OVClassBase *ovbase;
+ OVFunc *ovfunc;
+
+ if (cclass_root != ovclass) {
+ for (ovfunc = ovclass->vfuncs; ovfunc; ovfunc = ovfunc->next)
+ CClass_FindOVFunc(cclass_root, ovclass, ovfunc);
+ }
+
+ for (ovbase = ovclass->bases; ovbase; ovbase = ovbase->next)
+ CClass_OverrideOVClassTree(ovbase->ovclass);
+}
+
+static void CClass_AllocVTableRec(OVClass *ovclass) {
+ OVFunc *ovfunc;
+ Object *object;
+ SInt32 offset27;
+ SInt32 offset26;
+ SInt32 offset23;
+ OVClassBase *ovbase;
+ OLinkList *link;
+
+ if (ovclass->alloced_vtable)
+ return;
+
+ for (ovfunc = ovclass->vfuncs; ovfunc; ovfunc = ovfunc->next) {
+ offset27 = ovclass->voffset + TYPE_METHOD(ovfunc->obj->type)->x1E + CABI_GetVTableOffset(ovclass->tclass);
+ CError_ASSERT(1867, offset27 < vtable_data_size);
+
+ if (!(vtable_object_data[offset27])) {
+ if (ovfunc->ovfC) {
+ object = ovfunc->ovfC->obj;
+ if (
+ (TYPE_FUNC(object->type)->flags & FUNC_FLAGS_400000) &&
+ CClass_GetOverrideKind(TYPE_FUNC(ovfunc->obj->type), TYPE_FUNC(object->type), 0) == 2
+ )
+ {
+ CError_ASSERT(1887,
+ IS_TYPE_POINTER_ONLY(TYPE_FUNC(ovfunc->obj->type)->functype) &&
+ IS_TYPE_CLASS(TPTR_TARGET(TYPE_FUNC(ovfunc->obj->type)->functype)));
+ object = CClass_FindCovariantFunction(
+ object,
+ TPTR_TARGET(TYPE_FUNC(ovfunc->obj->type)->functype));
+ }
+
+ if ((offset26 = ovfunc->ovc8->offset - ovclass->offset)) {
+ if (!(TYPE_FUNC(object->type)->flags & FUNC_FLAGS_8)) {
+ cclass_ovbase = NULL;
+ CError_ASSERT(1899, CClass_IsBaseOf(ovclass, ovfunc->ovc8));
+
+ if (cclass_ovbase && (main_class->flags & CLASS_FLAGS_8000)) {
+ offset23 = ovclass->offset - cclass_ovbase->offset;
+ offset23 = CABI_GetCtorOffsetOffset(cclass_ovbase->tclass, NULL) - offset23;
+ CError_ASSERT(1906, offset23 > 0);
+ object = CClass_ThunkObject(object, offset26, 0, offset23);
+ } else {
+ object = CClass_ThunkObject(object, offset26, 0, -1);
+ }
+ }
+ }
+ } else {
+ object = ovfunc->obj;
+ }
+
+ if (!(TYPE_FUNC(object->type)->flags & FUNC_FLAGS_8)) {
+ link = lalloc(sizeof(OLinkList));
+ link->next = vtable_object_links;
+ link->obj = object;
+ link->offset = offset27;
+ link->somevalue = 0;
+ vtable_object_links = link;
+ vtable_object_data[offset27] = 1;
+ }
+ }
+ }
+
+ ovclass->alloced_vtable = 1;
+
+ for (ovbase = ovclass->bases; ovbase; ovbase = ovbase->next)
+ CClass_AllocVTableRec(ovbase->ovclass);
+}
+
+static Object *CClass_CheckClass(OVClass *ovclass, Boolean errorflag) {
+ Object *object;
+ Object *check;
+ OVFunc *ovfunc;
+ OVClassBase *ovbase;
+
+ object = NULL;
+
+ for (ovfunc = ovclass->vfuncs; ovfunc; ovfunc = ovfunc->next) {
+ if (ovfunc->ovf10 && errorflag)
+ CError_Error(CErrorStr251, main_class, 0, ovfunc->obj, ovfunc->ovfC->obj, ovfunc->ovf10->obj);
+
+ if (!object) {
+ check = ovfunc->ovfC ? ovfunc->ovfC->obj : ovfunc->obj;
+ if (TYPE_FUNC(check->type)->flags & FUNC_FLAGS_8)
+ object = check;
+ }
+ }
+
+ for (ovbase = ovclass->bases; ovbase; ovbase = ovbase->next) {
+ if (object)
+ CClass_CheckClass(ovbase->ovclass, errorflag);
+ else
+ object = CClass_CheckClass(ovbase->ovclass, errorflag);
+ }
+
+ return object;
+}
+
+static void CClass_AllocVTable(TypeClass *tclass) {
+ OVClass *ovclass;
+
+ main_class = tclass;
+ ovclass = CClass_BuildOVClassTree(NULL, tclass, 0, 0);
+ cclass_root = ovclass;
+ CClass_OverrideOVClassTree(ovclass);
+ CClass_CheckClass(ovclass, 1);
+ CClass_AllocVTableRec(ovclass);
+}
+
+static Object *CClass_CheckVirtuals(TypeClass *tclass) {
+ OVClass *ovclass;
+
+ main_class = tclass;
+ ovclass = CClass_BuildOVClassTree(NULL, tclass, 0, 0);
+ cclass_root = ovclass;
+ CClass_OverrideOVClassTree(ovclass);
+ return CClass_CheckClass(ovclass, 0);
+}
+
+static void CClass_CheckVirtualBaseOverrides(OVClass *a, OVClass *b, Boolean flag) {
+ VClassList *vbase;
+ OVFunc *ovfunc;
+ OVClassBase *ovbase;
+
+ if (flag) {
+ for (ovfunc = b->vfuncs; ovfunc; ovfunc = ovfunc->next) {
+ if (ovfunc->ovfC) {
+ cclass_ovbase = NULL;
+ CError_ASSERT(2040, CClass_IsBaseOf(b, ovfunc->ovc8));
+
+ if (cclass_ovbase) {
+ for (vbase = a->tclass->vbases; vbase; vbase = vbase->next) {
+ if (vbase->base == cclass_ovbase->tclass)
+ break;
+ }
+
+ CError_ASSERT(2047, vbase);
+ vbase->has_override = 1;
+ }
+ }
+ }
+ }
+
+ for (ovbase = b->bases; ovbase; ovbase = ovbase->next) {
+ CClass_CheckVirtualBaseOverrides(a, ovbase->ovclass, flag || ovbase->is_virtual);
+ }
+}
+
+static void CClass_CheckHideVirtual(OVClass *a, OVClass *b) {
+ OVClassBase *ovbase;
+ OVFunc *ovfunc;
+ Object *foundObject;
+ Boolean isAlias;
+ Object *object;
+ CScopeObjectIterator iter;
+
+ if (a != b) {
+ for (ovfunc = b->vfuncs; ovfunc; ovfunc = ovfunc->next) {
+ if (ovfunc->ovc8 != a) {
+ foundObject = NULL;
+ isAlias = 0;
+ CScope_InitObjectIterator(&iter, a->tclass->nspace);
+
+ while (1) {
+ if (!(object = OBJECT(CScope_NextObjectIteratorObject(&iter))))
+ break;
+
+ if (object->name == ovfunc->obj->name && IS_TYPE_FUNC(object->type)) {
+ if (object->datatype != DALIAS) {
+ if (!(TYPE_FUNC(object->type)->flags & FUNC_FLAGS_20))
+ foundObject = object;
+ } else {
+ if (object->u.alias.object == ovfunc->obj) {
+ // don't show a warning if this is just an alias to the base function
+ isAlias = 1;
+ break;
+ }
+ }
+ }
+ }
+
+ if (foundObject && !isAlias)
+ CError_Warning(CErrorStr225, foundObject, ovfunc->obj);
+ }
+ }
+ }
+
+ for (ovbase = b->bases; ovbase; ovbase = ovbase->next)
+ CClass_CheckHideVirtual(a, ovbase->ovclass);
+}
+
+void CClass_CheckOverrides(TypeClass *tclass) {
+ OVClass *tree;
+ Object *object;
+ ObjectList *objlist;
+ ClassList *base;
+ VClassList *vbase;
+ int i;
+ CScopeObjectIterator iter;
+
+ i = 0;
+ for (base = tclass->bases; base; base = base->next) {
+ base->offset = i;
+ base->voffset = i;
+ i++;
+ }
+ for (vbase = tclass->vbases; vbase; vbase = vbase->next) {
+ vbase->offset = i;
+ vbase->voffset = i;
+ i++;
+ }
+
+ main_class = tclass;
+ tree = CClass_BuildOVClassTree(NULL, tclass, 0, 0);
+ cclass_root = tree;
+
+ CClass_OverrideOVClassTree(tree);
+ if (CClass_CheckClass(tree, 0))
+ tclass->flags |= CLASS_FLAGS_ABSTRACT;
+
+ if (copts.warn_hidevirtual)
+ CClass_CheckHideVirtual(tree, tree);
+
+ if (tclass->flags & CLASS_FLAGS_8000)
+ CClass_CheckVirtualBaseOverrides(tree, tree, 0);
+
+ objlist = NULL;
+ CScope_InitObjectIterator(&iter, tclass->nspace);
+ while (1) {
+ if (!(object = OBJECT(CScope_NextObjectIteratorObject(&iter))))
+ break;
+
+ if (object->datatype == DVFUNC) {
+ CError_ASSERT(2175, IS_TYPE_FUNC(object->type));
+ if (TYPE_FUNC(object->type)->flags & FUNC_FLAGS_400000)
+ objlist = CClass_DeclareCovariantFuncs(objlist, object, tclass);
+ }
+ }
+
+ while (objlist) {
+ CScope_AddObject(tclass->nspace, objlist->object->name, OBJ_BASE(objlist->object));
+ objlist = objlist->next;
+ }
+
+ for (base = tclass->bases; base; base = base->next) {
+ base->offset = 0;
+ base->voffset = 0;
+ }
+ for (vbase = tclass->vbases; vbase; vbase = vbase->next) {
+ vbase->offset = 0;
+ vbase->voffset = 0;
+ }
+}
+
+static void CClass_FindDominator(TypeClass *tclass1, SInt32 offset1, Object *object1, TypeClass *tclass2, SInt32 offset2, TypeClass *tclass3) {
+ Object *object;
+ ClassList *base;
+ CScopeObjectIterator iter;
+
+ CScope_InitObjectIterator(&iter, tclass1->nspace);
+ while (1) {
+ if (!(object = OBJECT(CScope_NextObjectIteratorObject(&iter))))
+ break;
+
+ if (
+ object->name == cclass_dominator_vobject->name &&
+ object->datatype == DVFUNC &&
+ CClass_GetOverrideKind(TYPE_FUNC(cclass_dominator_vobject->type), TYPE_FUNC(object->type), 0)
+ )
+ {
+ if (object == cclass_dominator_vobject && offset1 == cclass_dominator_voffset) {
+ if (object1) {
+ if (cclass_dominator_oobject && cclass_dominator_ooffset != offset2) {
+ if (CClass_ClassDominates(cclass_dominator_oclass, tclass2))
+ return;
+ if (!CClass_ClassDominates(tclass2, cclass_dominator_oclass)) {
+ cclass_dominator_eobject = object1;
+ cclass_vbase = tclass3;
+ return;
+ }
+ }
+
+ cclass_dominator_oobject = object1;
+ cclass_dominator_ooffset = offset2;
+ cclass_dominator_oclass = tclass2;
+ cclass_dominator_eobject = NULL;
+ cclass_vbase = tclass3;
+ }
+ return;
+ } else {
+ if (!object1) {
+ object1 = object;
+ tclass2 = tclass1;
+ offset2 = offset1;
+ }
+ break;
+ }
+ }
+ }
+
+ for (base = tclass1->bases; base; base = base->next) {
+ if (base->base->vtable) {
+ if (!base->is_virtual) {
+ CClass_FindDominator(base->base, offset1 + base->offset, object1, tclass2, offset2, tclass3);
+ } else {
+ SInt32 vboffset = CClass_VirtualBaseOffset(main_class, base->base);
+ CClass_FindDominator(base->base, vboffset, object1, tclass2, offset2, base->base);
+ }
+ }
+ }
+}
+
+static void CClass_ConstructVTable(TypeClass *tclass, SInt32 voffset, SInt32 offset, TypeClass *baseclass) {
+ Object *object;
+ Object *thunkobject;
+ SInt32 newoffset;
+ SInt32 newvoffset;
+ ClassList *base;
+ SInt32 thunkoffset;
+ OLinkList *olink;
+ CScopeObjectIterator iter;
+
+ CScope_InitObjectIterator(&iter, tclass->nspace);
+ while (1) {
+ if (!(object = OBJECT(CScope_NextObjectIteratorObject(&iter))))
+ break;
+
+ if (object->datatype == DVFUNC) {
+ newoffset = voffset + TYPE_METHOD(object->type)->x1E + CABI_GetVTableOffset(tclass);
+ CError_ASSERT(2288, newoffset < vtable_data_size);
+
+ if (!vtable_object_data[newoffset]) {
+ cclass_dominator_vobject = object;
+ cclass_dominator_voffset = offset;
+ cclass_dominator_oobject = NULL;
+ cclass_dominator_ooffset = offset;
+ CClass_FindDominator(main_class, 0, NULL, NULL, 0, NULL);
+
+ if (cclass_dominator_oobject) {
+ if (cclass_dominator_eobject)
+ CError_Error(CErrorStr251, main_class, 0, cclass_dominator_vobject, cclass_dominator_oobject, cclass_dominator_eobject);
+ } else {
+ cclass_dominator_oobject = object;
+ cclass_vbase = NULL;
+ }
+
+ vtable_object_data[newoffset] = 1;
+
+ if (!(TYPE_FUNC(cclass_dominator_oobject->type)->flags & FUNC_FLAGS_8)) {
+ if (!check_pures) {
+ thunkobject = cclass_dominator_oobject;
+ if ((thunkoffset = cclass_dominator_ooffset - offset)) {
+ if (cclass_vbase && (main_class->flags & CLASS_FLAGS_8000)) {
+ thunkobject = CClass_ThunkObject(cclass_dominator_oobject, thunkoffset, 0,
+ CABI_GetCtorOffsetOffset(cclass_vbase, tclass));
+ } else {
+ thunkobject = CClass_ThunkObject(cclass_dominator_oobject, thunkoffset, 0, -1);
+ }
+ }
+
+ olink = lalloc(sizeof(OLinkList));
+ olink->next = vtable_object_links;
+ olink->obj = thunkobject;
+ olink->offset = newoffset;
+ olink->somevalue = 0;
+ vtable_object_links = olink;
+ }
+ } else {
+ found_pure = cclass_dominator_oobject;
+ }
+ }
+ }
+ }
+
+ for (base = tclass->bases; base; base = base->next) {
+ if (base->base->vtable) {
+ if (base->is_virtual) {
+ newoffset = CClass_VirtualBaseOffset(main_class, base->base);
+ newvoffset = CClass_VirtualBaseVTableOffset(main_class, base->base);
+ CClass_ConstructVTable(
+ base->base,
+ newvoffset,
+ newoffset,
+ base->base
+ );
+ } else {
+ CClass_ConstructVTable(
+ base->base,
+ voffset + base->voffset,
+ offset + base->offset,
+ baseclass
+ );
+ }
+ }
+ }
+}
+
+void CClass_ClassDefaultFuncAction(TypeClass *tclass) {
+}
+
+void CClass_ClassAction(TypeClass *tclass) {
+ if (tclass->sominfo) {
+ CSOM_GenerateClassStructures(tclass);
+ } else if (tclass->vtable) {
+ vtable_data_size = tclass->vtable->size;
+ vtable_object_data = lalloc(vtable_data_size);
+ memclrw(vtable_object_data, vtable_data_size);
+
+ main_class = tclass;
+ vtable_object_links = NULL;
+ found_pure = NULL;
+ check_pures = 0;
+
+ CClass_AllocVTable(tclass);
+
+ memclrw(vtable_object_data, vtable_data_size);
+ if (copts.useRTTI && !(tclass->flags & (CLASS_FLAGS_10 | CLASS_FLAGS_2000)))
+ vtable_object_links = CRTTI_ConstructVTableHeaders(tclass, vtable_object_data, vtable_object_links);
+
+ CError_ASSERT(2492, tclass->vtable->object->type->size == tclass->vtable->size);
+ CInit_DeclareData(tclass->vtable->object, vtable_object_data, vtable_object_links, tclass->vtable->size);
+ }
+}
+
+void CClass_MakeStaticActionClass(TypeClass *tclass) {
+ if (tclass->vtable) {
+ tclass->vtable->object->sclass = TK_STATIC;
+ tclass->vtable->object->qual |= Q_20000;
+ if (!(tclass->vtable->object->flags & OBJECT_FLAGS_2)) {
+ CParser_NewCallBackAction(tclass->vtable->object, tclass);
+ } else if (cparamblkptr->isPrecompiling != 1) {
+ CParser_NewClassAction(tclass);
+ }
+ }
+}
+
+Object *CClass_CheckPures(TypeClass *tclass) {
+ return CClass_CheckVirtuals(tclass);
+}
+
+void CClass_MemberDef(Object *obj, TypeClass *tclass) {
+ switch (tclass->action) {
+ case CLASS_ACTION_0:
+ break;
+ case CLASS_ACTION_1:
+ if (IS_TYPE_FUNC(obj->type) && (TYPE_FUNC(obj->type)->flags & FUNC_FLAGS_4)) {
+ if (obj->qual & Q_INLINE) {
+ if (tclass->sominfo)
+ CError_Error(CErrorStr280);
+ tclass->action = CLASS_ACTION_0;
+ CClass_MakeStaticActionClass(tclass);
+ } else if (cparamblkptr->isPrecompiling != 1) {
+ CParser_NewClassAction(tclass);
+ }
+ }
+ break;
+ case CLASS_ACTION_2:
+ CError_FATAL(2682);
+ break;
+ case CLASS_ACTION_3:
+ break;
+ default:
+ CError_FATAL(2701);
+ }
+}
+
+Object *CClass_ThisSelfObject(void) {
+ ObjectList *list;
+
+ if (cscope_currentfunc && cscope_currentclass) {
+ if (cscope_currentclass->objcinfo) {
+ for (list = arguments; list; list = list->next) {
+ if (list->object->name == self_name_node)
+ return list->object;
+ }
+ CError_Error(CErrorStr301);
+ } else {
+ if (cscope_is_member_func) {
+ for (list = arguments; list; list = list->next) {
+ if (list->object->name == this_name_node)
+ return list->object;
+ }
+ }
+ CError_Error(CErrorStr189);
+ }
+ }
+
+ CError_Error(copts.cplusplus ? CErrorStr189 : CErrorStr301);
+ return NULL;
+}
+
+ENode *CClass_CreateThisSelfExpr(void) {
+ Object *object;
+ ENode *expr;
+
+ if (!(object = CClass_ThisSelfObject()))
+ return NULL;
+
+ expr = create_objectrefnode(object);
+ expr->rtype = CDecl_NewPointerType(TYPE(cscope_currentclass));
+ expr = makemonadicnode(expr, EINDIRECT);
+ expr->data.monadic->rtype = CDecl_NewPointerType(expr->rtype);
+
+ return expr;
+}
+
+static AccessType CClass_BaseMemberAccess(BClassList *path, AccessType access) {
+ ClassList *base;
+
+ if (path->next) {
+ access = CClass_BaseMemberAccess(path->next, access);
+ switch (access) {
+ case ACCESSPRIVATE:
+ case ACCESSNONE:
+ return ACCESSNONE;
+ }
+
+ for (base = TYPE_CLASS(path->type)->bases; ; base = base->next) {
+ if (!base)
+ return ACCESSNONE;
+
+ if (base->base == TYPE_CLASS(path->next->type)) {
+ switch (base->access) {
+ case ACCESSNONE:
+ access = ACCESSNONE;
+ break;
+ case ACCESSPROTECTED:
+ if (access == ACCESSPUBLIC)
+ access = ACCESSPROTECTED;
+ break;
+ case ACCESSPRIVATE:
+ if (access == ACCESSPRIVATE)
+ access = ACCESSNONE;
+ else
+ access = ACCESSPRIVATE;
+ break;
+ case ACCESSPUBLIC:
+ break;
+ }
+ break;
+ }
+ }
+ }
+
+ return access;
+}
+
+static Boolean CClass_CanAccess(BClassList *path, AccessType access) {
+ AccessType access2;
+ BClassList *scan;
+ BClassList *next;
+ TypeClass *prevclass;
+ TypeClass *tclass;
+ ClassList *base;
+ ClassFriend *cfriend;
+
+ tclass = TYPE_CLASS(path->type);
+ access2 = access;
+ if ((scan = path->next)) {
+ if (access2 != ACCESSPRIVATE) {
+ prevclass = tclass;
+ while (scan) {
+ for (base = prevclass->bases; base; base = base->next) {
+ if (base->base == TYPE_CLASS(scan->type))
+ break;
+ }
+
+ if (!base)
+ return 0;
+
+ switch (base->access) {
+ case ACCESSNONE:
+ access2 = ACCESSNONE;
+ break;
+ case ACCESSPROTECTED:
+ if (access2 == ACCESSPUBLIC)
+ access2 = ACCESSPROTECTED;
+ break;
+ case ACCESSPRIVATE:
+ if (access2 == ACCESSPRIVATE)
+ access2 = ACCESSNONE;
+ else
+ access2 = ACCESSPRIVATE;
+ break;
+ case ACCESSPUBLIC:
+ break;
+ }
+
+ prevclass = TYPE_CLASS(scan->type);
+ scan = scan->next;
+ }
+ } else {
+ access2 = ACCESSNONE;
+ }
+ }
+
+ if (access2 == ACCESSPUBLIC)
+ return 1;
+
+ if (access2 != ACCESSNONE) {
+ if (cscope_currentclass == tclass)
+ return 1;
+ if (cobjc_currentclass == tclass)
+ return 1;
+
+ for (cfriend = tclass->friends; cfriend; cfriend = cfriend->next) {
+ if (cfriend->isclass) {
+ if (cfriend->u.theclass == cscope_currentclass)
+ return 1;
+ } else {
+ if (cfriend->u.obj == cscope_currentfunc)
+ return 1;
+ }
+ }
+ }
+
+ for (scan = path; scan->next; scan = scan->next) {
+ if (CClass_CanAccess(scan->next, access)) {
+ if ((next = scan->next->next) || access != ACCESSPUBLIC) {
+ scan->next->next = NULL;
+ if (CClass_CanAccess(path, ACCESSPUBLIC)) {
+ scan->next->next = next;
+ return 1;
+ }
+ scan->next->next = next;
+ }
+ }
+ }
+
+ return 0;
+}
+
+void CClass_CheckPathAccess(BClassList *path, Object *obj, AccessType access) {
+ if (!CClass_CanAccess(path, access)) {
+ if (path && obj)
+ CError_Error(CErrorStr381, path->type, 0, obj);
+ else
+ CError_Error(CErrorStr187);
+ }
+}
+
+static BClassList *CClass_PathCleanup(BClassList *path, TypeClass *tclass) {
+ BClassList *first;
+ ClassList *base;
+
+ first = path;
+
+ while (1) {
+ if (!path->next) {
+ if (!tclass)
+ return first;
+ if (path->type == TYPE(tclass))
+ return first;
+ return NULL;
+ }
+
+ if (path->type != path->next->type) {
+ for (base = TYPE_CLASS(path->type)->bases; base; base = base->next) {
+ if (base->base == TYPE_CLASS(path->next->type))
+ break;
+ }
+
+ if (base) {
+ path = path->next;
+ } else {
+ first = path = path->next;
+ }
+ } else {
+ path->next = path->next->next;
+ }
+ }
+}
+
+void CClass_CheckStaticAccess(BClassList *path, TypeClass *tclass, AccessType access) {
+ ClassFriend *cfriend;
+
+ if (path) {
+ path = CClass_PathCleanup(path, tclass);
+ if (path && path->next) {
+ if (!CClass_CanAccess(path, access))
+ CError_Error(CErrorStr187);
+ return;
+ }
+ }
+
+ switch (access) {
+ case ACCESSPUBLIC:
+ return;
+ case ACCESSPRIVATE:
+ case ACCESSPROTECTED:
+ if (tclass == cscope_currentclass)
+ return;
+
+ for (cfriend = tclass->friends; cfriend; cfriend = cfriend->next) {
+ if (cfriend->isclass) {
+ if (cfriend->u.theclass == cscope_currentclass)
+ return;
+ } else {
+ if (cfriend->u.obj == cscope_currentfunc)
+ return;
+ }
+ }
+ case ACCESSNONE:
+ CError_Warning(CErrorStr187);
+ return;
+ default:
+ CError_FATAL(3013);
+ }
+}
+
+void CClass_CheckObjectAccess(BClassList *path, Object *obj) {
+ short depth;
+ Boolean isambigbase;
+
+ if (obj->nspace && obj->nspace->theclass) {
+ if (!path && cscope_currentclass)
+ path = CClass_GetBasePath(cscope_currentclass, obj->nspace->theclass, &depth, &isambigbase);
+
+ CClass_CheckStaticAccess(path, obj->nspace->theclass, obj->access);
+ }
+}
+
+void CClass_CheckEnumAccess(BClassList *path, ObjEnumConst *objec) {
+ if (path) {
+ if ((path = CClass_PathCleanup(path, NULL))) {
+ if (!CClass_CanAccess(path, objec->access))
+ CError_Error(CErrorStr187);
+ return;
+ }
+ }
+
+ if (
+ objec->access != ACCESSPUBLIC &&
+ IS_TYPE_ENUM(objec->type) &&
+ TYPE_ENUM(objec->type)->nspace &&
+ TYPE_ENUM(objec->type)->nspace->theclass
+ )
+ CClass_CheckStaticAccess(NULL, TYPE_ENUM(objec->type)->nspace->theclass, objec->access);
+}
+
+static Type *CClass_PointerTypeCopy(Type *type) {
+ Type *copy;
+
+ switch (type->type) {
+ case TYPEPOINTER:
+ case TYPEARRAY:
+ copy = galloc(sizeof(TypePointer));
+ *TYPE_POINTER(copy) = *TYPE_POINTER(type);
+ TPTR_TARGET(copy) = CClass_PointerTypeCopy(TPTR_TARGET(copy));
+ return copy;
+ case TYPEMEMBERPOINTER:
+ copy = galloc(sizeof(TypeMemberPointer));
+ *TYPE_MEMBER_POINTER(copy) = *TYPE_MEMBER_POINTER(type);
+ return copy;
+ default:
+ return type;
+ }
+}
+
+Type *CClass_CombineClassAccessQualifiers(Type *type, UInt32 qual1, UInt32 qual2, UInt32 *outflags) {
+ Type *inner;
+
+ qual2 = qual2 & (Q_CONST | Q_VOLATILE);
+ if (qual1 & Q_MUTABLE)
+ qual2 &= ~Q_CONST;
+ qual1 = qual1 & (Q_CONST | Q_VOLATILE);
+
+ inner = type;
+ while (IS_TYPE_ARRAY(inner))
+ inner = TPTR_TARGET(inner);
+
+ switch (inner->type) {
+ case TYPEMEMBERPOINTER:
+ case TYPEPOINTER:
+ if (qual2) {
+ type = CClass_PointerTypeCopy(type);
+ inner = type;
+ while (IS_TYPE_ARRAY(inner))
+ inner = TPTR_TARGET(inner);
+
+ switch (inner->type) {
+ case TYPEPOINTER:
+ TPTR_QUAL(inner) |= qual2;
+ break;
+ case TYPEMEMBERPOINTER:
+ TYPE_MEMBER_POINTER(inner)->qual |= qual2;
+ break;
+ default:
+ CError_FATAL(3125);
+ }
+ }
+ break;
+ default:
+ qual1 |= qual2;
+ }
+
+ *outflags = qual1;
+ return type;
+}
+
+static void CClass_OptimizeBitFieldAccess(Type **ptype, SInt32 *poffset) {
+ Type *innertype;
+ TypeBitfield *newtype;
+ short i;
+
+ innertype = TYPE_BITFIELD(*ptype)->bitfieldtype;
+ if (TYPE_BITFIELD(*ptype)->unkB == 8) {
+ switch (TYPE_BITFIELD(*ptype)->unkA) {
+ case 0:
+ i = 0;
+ break;
+ case 8:
+ i = 1;
+ break;
+ case 16:
+ i = 2;
+ break;
+ case 24:
+ i = 3;
+ break;
+ default:
+ i = -1;
+ break;
+ }
+
+ if (i >= 0) {
+ if (innertype->size != 1) {
+ if (is_unsigned(TYPE_BITFIELD(*ptype)->bitfieldtype))
+ *ptype = TYPE(&stunsignedchar);
+ else
+ *ptype = TYPE(&stsignedchar);
+ } else {
+ *ptype = innertype;
+ }
+ *poffset += i;
+ return;
+ }
+ }
+
+ if (TYPE_BITFIELD(*ptype)->unkB == 16) {
+ switch (TYPE_BITFIELD(*ptype)->unkA) {
+ case 0:
+ i = 0;
+ break;
+ case 16:
+ i = 2;
+ break;
+ default:
+ i = -1;
+ break;
+ }
+
+ if (i >= 0) {
+ if (innertype->size != stsignedshort.size) {
+ if (is_unsigned(innertype))
+ *ptype = TYPE(&stunsignedshort);
+ else
+ *ptype = TYPE(&stsignedshort);
+ } else {
+ *ptype = innertype;
+ }
+ *poffset += i;
+ return;
+ }
+ }
+
+ if (TYPE_BITFIELD(*ptype)->unkB == 32 && TYPE_BITFIELD(*ptype)->unkA == 0) {
+ if (innertype->size != stsignedlong.size) {
+ if (is_unsigned(innertype))
+ *ptype = TYPE(&stunsignedlong);
+ else
+ *ptype = TYPE(&stsignedlong);
+ } else {
+ *ptype = innertype;
+ }
+ return;
+ }
+
+ if ((*ptype)->size != stsignedchar.size) {
+ i = TYPE_BITFIELD(*ptype)->unkA + TYPE_BITFIELD(*ptype)->unkB - 1;
+
+ if (TYPE_BITFIELD(*ptype)->unkB < 8 && (TYPE_BITFIELD(*ptype)->unkA & 0xFFF8) == (i & 0xFFF8)) {
+ newtype = galloc(sizeof(TypeBitfield));
+ *newtype = *TYPE_BITFIELD(*ptype);
+ *ptype = TYPE(newtype);
+
+ i = 0;
+ if (newtype->unkA >= 8)
+ i = 1;
+ if (newtype->unkA >= 16)
+ i = 2;
+ if (newtype->unkA >= 24)
+ i = 3;
+ *poffset += i;
+ newtype->unkA -= 8 * i;
+
+ newtype->bitfieldtype = is_unsigned(innertype) ? TYPE(&stunsignedchar) : TYPE(&stsignedchar);
+ newtype->size = newtype->bitfieldtype->size;
+ return;
+ }
+
+ if ((*ptype)->size != stsignedshort.size) {
+ if (TYPE_BITFIELD(*ptype)->unkB < 16 && (TYPE_BITFIELD(*ptype)->unkA & 0xFFF0) == (i & 0xFFF0)) {
+ newtype = galloc(sizeof(TypeBitfield));
+ *newtype = *TYPE_BITFIELD(*ptype);
+ *ptype = TYPE(newtype);
+
+ i = 0;
+ if (newtype->unkA >= 16)
+ i = stsignedshort.size;
+ *poffset += i;
+ newtype->unkA -= 8 * i;
+
+ newtype->bitfieldtype = is_unsigned(innertype) ? TYPE(&stunsignedshort) : TYPE(&stsignedshort);
+ newtype->size = newtype->bitfieldtype->size;
+ return;
+ }
+ }
+ }
+}
+
+ENode *CClass_AccessMember(ENode *classexpr, Type *type, UInt32 qual, SInt32 offset) {
+ Type *innertype;
+ UInt32 flags;
+
+ innertype = NULL;
+
+ if (IS_TYPE_CLASS(classexpr->rtype) && (TYPE_CLASS(classexpr->rtype)->flags & CLASS_FLAGS_1)) {
+ classexpr = makemonadicnode(classexpr, EINDIRECT);
+ classexpr->data.monadic->rtype = CDecl_NewPointerType(classexpr->rtype);
+ }
+
+ if (IS_TYPE_BITFIELD(type)) {
+ innertype = TYPE_BITFIELD(type)->bitfieldtype;
+ CClass_OptimizeBitFieldAccess(&type, &offset);
+ }
+
+ if (offset && !canadd(classexpr->data.monadic, offset)) {
+ classexpr->data.monadic = makediadicnode(
+ classexpr->data.monadic,
+ intconstnode(TYPE(&stunsignedlong), offset),
+ EADD);
+ optimizecomm(classexpr->data.monadic);
+ }
+
+ if (innertype) {
+ if (IS_TYPE_BITFIELD(type)) {
+ classexpr->data.monadic = makemonadicnode(classexpr->data.monadic, EBITFIELD);
+ classexpr->data.monadic->rtype = type;
+ classexpr->rtype = TYPE_BITFIELD(type)->bitfieldtype;
+ } else {
+ classexpr->rtype = type;
+ }
+ } else {
+ classexpr->rtype = type;
+ }
+
+ classexpr->rtype = CClass_CombineClassAccessQualifiers(classexpr->rtype, qual, ENODE_QUALS(classexpr), &flags);
+ classexpr->flags = flags;
+ return classexpr;
+}
diff --git a/compiler_and_linker/unsorted/CDecl.c b/compiler_and_linker/unsorted/CDecl.c
index 63f2d0f..0ee3cf8 100644
--- a/compiler_and_linker/unsorted/CDecl.c
+++ b/compiler_and_linker/unsorted/CDecl.c
@@ -1,68 +1,30 @@
#include "compiler/CDecl.h"
-#include "compiler/CompilerTools.h"
-#include "compiler/CError.h"
-#include "compiler/objects.h"
-#include "compiler/scopes.h"
-#include "compiler/templates.h"
-#include "compiler/tokens.h"
-#include "compiler/CPrep.h"
-#include "compiler/CPrepTokenizer.h"
-#include "compiler/CMangler.h"
+#include "compiler/CABI.h"
+#include "compiler/CBrowse.h"
#include "compiler/CClass.h"
-#include "compiler/CParser.h"
+#include "compiler/CError.h"
+#include "compiler/CException.h"
+#include "compiler/CExpr.h"
#include "compiler/CFunc.h"
#include "compiler/CInit.h"
+#include "compiler/CInline.h"
#include "compiler/CInt64.h"
-#include "compiler/CExpr.h"
#include "compiler/CMachine.h"
-#include "compiler/CInline.h"
-#include "compiler/CABI.h"
-
-// TODO MOVE ME
-extern void CExcept_ScanExceptionSpecification(TypeFunc *tfunc);
-extern void CExcept_CompareSpecifications(ExceptSpecList *a, ExceptSpecList *b);
-extern void CObjC_ParseDefs(TypeStruct *tstruct);
-extern void CTempl_Parse(TypeClass *tclass, short access);
-extern Boolean CTempl_InstantiateTemplateClass(TemplClass *cls);
-extern Boolean CTemplTool_IsTemplateArgumentDependentType(Type *type);
-extern TemplClass *CTemplTool_GetSelfRefTemplate(Type *type);
-extern Type *CTemplTool_ResolveMemberSelfRefs(TypeClass *tclass, Type *type, UInt32 *qual);
-extern Boolean CTempl_IsQualifiedMember(DeclInfo *declinfo, Type *type, NameSpace **nspace);
-extern Object *CTempl_TemplateFunctionCheck(DeclInfo *declinfo, NameSpaceObjectList *list);
-extern TemplArg *CTempl_ParseUncheckTemplArgs(void *a, Boolean flag);
-extern TemplArg *CTemplTool_MakeGlobalTemplArgCopy(TemplArg *args);
-extern void CTemplClass_RegisterFriend(TemplClass *tmclass, DeclInfo *declinfo);
-extern void CTemplClass_RegisterBaseClass(TemplClass *tmclass, Type *baseclass, short access, Boolean is_virtual);
-extern void CTemplClass_RegisterObjectDef(TemplClass *tmclass, ObjBase *obj);
-extern void CTemplClass_RegisterObjectInit(TemplClass *tmclass, ObjBase *obj, ENode *expr);
-extern void CTemplClass_DefineMember(TemplClass *tmclass, Object *obj, FileOffsetInfo *fileoffset, TStream *stream);
-extern void CTemplClass_CompleteClass(TemplClass *templ, DeclE *decle);
-extern void CTemplClass_RegisterEnumType(TemplClass *tmclass, TypeEnum *tenum);
-extern void CTemplClass_RegisterEnumerator(TemplClass *tmclass, ObjEnumConst *oec, ENode *expr);
-extern TypeClass *CTemplClass_DefineNestedClass(TemplClass *tmclass, HashNameNode *name, short mode);
-extern void CSOM_FixNewDeleteFunctype(TypeFunc *tfunc);
-extern void CSOM_CheckFuncType(TypeFunc *tfunc);
-extern void CSOM_ClassComplete(TypeClass *tclass);
-extern void CSOM_MakeSOMClass(TypeClass *tclass);
-typedef struct BrowseStruct {
- void *x0;
- void *x4;
- void *x8;
- void *xC;
-} BrowseStruct;
-extern void CBrowse_BeginStruct(DeclInfo *declinfo, TypeStruct *type, BrowseStruct *bs);
-extern void CBrowse_EndStruct(SInt32 offset, BrowseStruct *bs);
-extern void CBrowse_AddStructMember(StructMember *member, SInt32 tokenoffset, SInt32 fileoffset);
-extern void CBrowse_BeginClass(DeclInfo *declinfo, BrowseStruct *bs);
-extern void CBrowse_EndClass(SInt32 offset, BrowseStruct *bs);
-extern void CBrowse_NewTypedef(NameSpace *nspace, HashNameNode *name, CPrepFileInfo *file, SInt32 tokenline, SInt32 tokenoffset, SInt32 fileoffset);
-extern void CBrowse_NewData(Object *obj, CPrepFileInfo *file, SInt32 tokenline, SInt32 tokenoffset, SInt32 fileoffset);
-extern void CBrowse_NewFunction(Object *obj, CPrepFileInfo *file, CPrepFileInfo *file2, SInt32 tokenoffset, SInt32 fileoffset);
-extern void CBrowse_NewEnum(NameSpace *nspace, HashNameNode *name, CPrepFileInfo *file, CPrepFileInfo *file2, SInt32 tokenoffset, SInt32 fileoffset);
-extern void CBrowse_NewEnumConstant(NameSpace *nspace, HashNameNode *name, CPrepFileInfo *file, CPrepFileInfo *file2, SInt32 tokenoffset, SInt32 fileoffset);
-extern void CBrowse_AddClassMemberData(Object *obj, SInt32 tokenoffset, SInt32 fileoffset);
-extern void CBrowse_AddClassMemberFunction(Object *obj, SInt32 tokenoffset, SInt32 fileoffset);
-extern void CBrowse_AddClassMemberVar(ObjMemberVar *obj, SInt32 tokenoffset, SInt32 fileoffset);
+#include "compiler/CMangler.h"
+#include "compiler/CObjC.h"
+#include "compiler/CParser.h"
+#include "compiler/CPrep.h"
+#include "compiler/CPrepTokenizer.h"
+#include "compiler/CSOM.h"
+#include "compiler/CTemplateClass.h"
+#include "compiler/CTemplateFunc.h"
+#include "compiler/CTemplateNew.h"
+#include "compiler/CTemplateTools.h"
+#include "compiler/CompilerTools.h"
+#include "compiler/objects.h"
+#include "compiler/scopes.h"
+#include "compiler/templates.h"
+#include "compiler/tokens.h"
AccessType global_access;
FileOffsetInfo member_fileoffset;
@@ -213,7 +175,7 @@ void CDecl_CompleteType(Type *type) {
}
if ((TYPE_CLASS(type)->flags & (CLASS_FLAGS_2 | CLASS_FLAGS_800)) == CLASS_FLAGS_800)
- CTempl_InstantiateTemplateClass(TEMPL_CLASS(type));
+ CTempl_InstantiateTemplateClass(TYPE_CLASS(type));
}
Boolean IsCompleteType(Type *type) {
@@ -231,8 +193,14 @@ Boolean IsCompleteType(Type *type) {
}
return 1;
case TYPECLASS:
- if (!(TYPE_CLASS(type)->flags & CLASS_FLAGS_2) && (!(TYPE_CLASS(type)->flags & CLASS_FLAGS_800) || !CTempl_InstantiateTemplateClass(
- TEMPL_CLASS(type)))) {
+ if (
+ !(TYPE_CLASS(type)->flags & CLASS_FLAGS_2) &&
+ (
+ !(TYPE_CLASS(type)->flags & CLASS_FLAGS_800) ||
+ !CTempl_InstantiateTemplateClass(TYPE_CLASS(type))
+ )
+ )
+ {
CError_Error(136, type, 0);
return 0;
}
@@ -418,7 +386,7 @@ void CDecl_ParseDirectFuncDecl(DeclInfo *declinfo) {
if (copts.cplusplus) {
CDecl_ParseCPPFuncDecl(tfunc);
- if (declinfo->storageclass == OBJECT_SCLASS_104 && tfunc->exspecs)
+ if (declinfo->storageclass == TK_TYPEDEF && tfunc->exspecs)
CError_Error(264);
}
@@ -638,11 +606,13 @@ static Boolean CDecl_IsEnumClassTypeOrRef(Type *type) {
return IS_TYPE_CLASS(type) || IS_TYPE_ENUM(type);
}
-#define OpMysteryValue0 0
-#define OpMysteryValue1 1
-#define OpMysteryValue2 2
-#define OpMysteryValue3 3
-#define OpMysteryValue4 4
+typedef enum OpMysteryValue {
+ OpMysteryValue0 = 0,
+ OpMysteryValue1 = 1,
+ OpMysteryValue2 = 2,
+ OpMysteryValue3 = 3,
+ OpMysteryValue4 = 4
+} OpMysteryValue;
static Boolean CDecl_CheckOperatorType(DeclInfo *declinfo, Boolean flag) {
FuncArg *args;
@@ -675,7 +645,11 @@ static Boolean CDecl_CheckOperatorType(DeclInfo *declinfo, Boolean flag) {
secondarg = args->next;
if (secondarg) {
- r27 = ((secondarg != &elipsis && !secondarg->next) != 0) ? OpMysteryValue4 : OpMysteryValue3;
+ //r27 = ((secondarg != &elipsis && !secondarg->next) != 0) ? OpMysteryValue2 : OpMysteryValue3;
+ if ((secondarg != &elipsis && !secondarg->next) != 0)
+ r27 = OpMysteryValue2;
+ else
+ r27 = OpMysteryValue3;
if (secondarg->dexpr) {
switch (declinfo->x3E) {
case '(':
@@ -1416,11 +1390,11 @@ void CheckDefaultArgs(FuncArg *args) {
}
static void CDecl_FuncRedeclCheck(Object *obj, DeclInfo *declinfo, Boolean flag) {
- if (declinfo->storageclass == OBJECT_SCLASS_102 && obj->sclass != OBJECT_SCLASS_102) {
+ if (declinfo->storageclass == TK_STATIC && obj->sclass != TK_STATIC) {
if (copts.cplusplus)
CError_Error(260);
else
- obj->sclass = OBJECT_SCLASS_102;
+ obj->sclass = TK_STATIC;
}
obj->qual |= declinfo->qual;
@@ -1460,8 +1434,7 @@ Object *CDecl_GetFunctionObject(DeclInfo *declinfo, NameSpace *nspace, Boolean *
}
if (nspace2->theclass) {
-#line 1969
- CError_ASSERT(declinfo->name);
+ CError_ASSERT(1969, declinfo->name);
if (!nspace2->theclass->size)
CDecl_CompleteType((Type *) nspace2->theclass);
if (!(list = CScope_GetLocalObject(nspace2, declinfo->name))) {
@@ -1614,8 +1587,7 @@ void CDecl_TypedefDeclarator(DeclInfo *declinfo) {
CError_Error(322);
return;
default:
-#line 2156
- CError_FATAL();
+ CError_FATAL(2156);
}
}
@@ -1654,8 +1626,8 @@ void CDecl_TypedefDeclarator(DeclInfo *declinfo) {
}
}
- if (cparamblkptr->browseOptions.recordTypedefs && declinfo->fileoffsetinfo.file->recordbrowseinfo)
- CBrowse_NewTypedef(nspace, declinfo->name, declinfo->fileoffsetinfo.file, declinfo->fileoffsetinfo.tokenline, declinfo->fileoffsetinfo.tokenoffset, CPrep_BrowserFileOffset());
+ if (cparamblkptr->browseOptions.recordTypedefs && declinfo->file->recordbrowseinfo)
+ CBrowse_NewTypedef(nspace, declinfo->name, declinfo->file, declinfo->file2, declinfo->x60, CPrep_BrowserFileOffset());
}
static void CDecl_DataDeclarator(DeclInfo *declinfo, short access, Boolean flag) {
@@ -1697,8 +1669,7 @@ static void CDecl_DataDeclarator(DeclInfo *declinfo, short access, Boolean flag)
CError_Error(221);
break;
default:
-#line 2281
- CError_FATAL();
+ CError_FATAL(2281);
}
}
@@ -1706,24 +1677,24 @@ static void CDecl_DataDeclarator(DeclInfo *declinfo, short access, Boolean flag)
if (!flag)
CDecl_CompleteType(declinfo->thetype);
switch (declinfo->storageclass) {
- case OBJECT_SCLASS_103:
+ case TK_EXTERN:
if (tk == '=' || tk == '(')
declinfo->storageclass = 0;
break;
case 0:
if (CParser_IsConst(declinfo->thetype, declinfo->qual)) {
- if ((!obj && !nspace->theclass) || (obj && obj->sclass != OBJECT_SCLASS_103 && !obj->nspace->theclass))
- declinfo->storageclass = OBJECT_SCLASS_102;
+ if ((!obj && !nspace->theclass) || (obj && obj->sclass != TK_EXTERN && !obj->nspace->theclass))
+ declinfo->storageclass = TK_STATIC;
}
break;
}
} else {
- if (declinfo->storageclass == OBJECT_SCLASS_103 && tk == '=')
+ if (declinfo->storageclass == TK_EXTERN && tk == '=')
declinfo->storageclass = 0;
}
if (IS_TYPE_ARRAY(declinfo->thetype) && !declinfo->thetype->size && !declinfo->storageclass && tk != '=')
- declinfo->storageclass = OBJECT_SCLASS_103;
+ declinfo->storageclass = TK_EXTERN;
if (obj) {
if ((!obj->type->size || !declinfo->thetype->size) && IS_TYPE_ARRAY(declinfo->thetype) && IS_TYPE_ARRAY(obj->type))
@@ -1740,8 +1711,8 @@ static void CDecl_DataDeclarator(DeclInfo *declinfo, short access, Boolean flag)
CError_Error(333, obj);
}
- if (declinfo->storageclass != OBJECT_SCLASS_103) {
- if (obj->sclass != OBJECT_SCLASS_103 && declinfo->storageclass && obj->sclass != declinfo->storageclass)
+ if (declinfo->storageclass != TK_EXTERN) {
+ if (obj->sclass != TK_EXTERN && declinfo->storageclass && obj->sclass != declinfo->storageclass)
CError_Error(333, obj);
if (tmpflag) {
@@ -1788,15 +1759,14 @@ static void CDecl_DataDeclarator(DeclInfo *declinfo, short access, Boolean flag)
CInit_InitializeData(obj);
}
- if (declinfo->fileoffsetinfo.file->recordbrowseinfo && obj->sclass != OBJECT_SCLASS_103)
- CBrowse_NewData(obj, declinfo->fileoffsetinfo.file, declinfo->fileoffsetinfo.tokenline, declinfo->fileoffsetinfo.tokenoffset, CPrep_BrowserFileOffset());
+ if (declinfo->file->recordbrowseinfo && obj->sclass != TK_EXTERN)
+ CBrowse_NewData(obj, declinfo->file, declinfo->file2, declinfo->x60, CPrep_BrowserFileOffset());
} else if (tk == '=') {
tk = lex();
expr = CExpr_IntegralConstOrDepExpr();
if (IS_TYPE_TEMPLATE(obj->type) || !ENODE_IS(expr, EINTCONST)) {
-#line 2426
- CError_ASSERT(nspace->theclass && (nspace->theclass->flags & CLASS_FLAGS_100));
- CTemplClass_RegisterObjectInit(TEMPL_CLASS(nspace->theclass), OBJ_BASE(obj), expr);
+ CError_ASSERT(2426, nspace->theclass && (nspace->theclass->flags & CLASS_FLAGS_100));
+ CTemplClass_RegisterObjectInit(TEMPL_CLASS(nspace->theclass), obj, expr);
} else if ((obj->qual & Q_CONST) && IS_TYPE_INT_OR_ENUM(obj->type)) {
obj->u.data.u.intconst = expr->data.intval;
obj->qual |= Q_10000 | Q_20000;
@@ -1820,21 +1790,20 @@ Boolean CDecl_FunctionDeclarator(DeclInfo *declinfo, NameSpace *nspace, Boolean
}
if (obj->nspace == cscope_root && !strcmp(obj->name->name, "main")) {
- if (obj->sclass == OBJECT_SCLASS_102 || (copts.ANSI_strict && TYPE_FUNC(obj->type)->functype != (Type *) &stsignedint))
+ if (obj->sclass == TK_STATIC || (copts.ANSI_strict && TYPE_FUNC(obj->type)->functype != (Type *) &stsignedint))
CError_Error(334);
- } else if (copts.require_prototypes && (pflag || declinfo->fileoffsetinfo.is_inline)) {
- if (obj->sclass != OBJECT_SCLASS_102 && !(obj->qual & Q_INLINE) && !obj->nspace->is_unnamed)
+ } else if (copts.require_prototypes && (pflag || declinfo->x64)) {
+ if (obj->sclass != TK_STATIC && !(obj->qual & Q_INLINE) && !obj->nspace->is_unnamed)
CError_Warning(178);
}
CFunc_ParseFuncDef(obj, declinfo, NULL, 0, 0, NULL);
- // WARNING: WEIRD FileOffsetInfo ALERT
- if (declinfo->fileoffsetinfo.file->recordbrowseinfo)
+ if (declinfo->file->recordbrowseinfo)
CBrowse_NewFunction(
obj,
- declinfo->fileoffsetinfo.file,
- (CPrepFileInfo *) declinfo->fileoffsetinfo.tokenline,
- declinfo->fileoffsetinfo.tokenoffset,
+ declinfo->file,
+ declinfo->file2,
+ declinfo->x60,
CPrep_BrowserFileOffset());
if (copts.cplusplus && lookahead() == ';')
@@ -1851,11 +1820,9 @@ static void CDecl_ParseSpecialMember(DeclInfo *declinfo, Boolean flag) {
NameSpace *r25;
if (!(r28 = declinfo->x10)) {
-#line 2544
- CError_ASSERT(declinfo->x14);
- r28 = declinfo->x14->object;
-#line 2546
- CError_ASSERT(r28->otype == OT_OBJECT);
+ CError_ASSERT(2544, declinfo->x14);
+ r28 = OBJECT(declinfo->x14->object);
+ CError_ASSERT(2546, r28->otype == OT_OBJECT);
}
if (!r28->nspace->theclass) {
@@ -1900,8 +1867,7 @@ static void CDecl_ParseSpecialMember(DeclInfo *declinfo, Boolean flag) {
}
return;
} else if (TYPE_FUNC(r28->type)->flags & FUNC_FLAGS_40) {
-#line 2603
- CError_FATAL();
+ CError_FATAL(2603);
declinfo->thetype = TYPE_FUNC(r28->type)->functype;
declinfo->qual |= TYPE_FUNC(r28->type)->qual;
@@ -1967,7 +1933,7 @@ void CDecl_ScanDeclarator(DeclInfo *declinfo) {
return;
}
- if (declinfo->storageclass && declinfo->storageclass != OBJECT_SCLASS_103)
+ if (declinfo->storageclass && declinfo->storageclass != TK_EXTERN)
CError_Error(177);
if (IS_TYPE_FUNC(declinfo->thetype)) {
@@ -1983,7 +1949,7 @@ void CDecl_ScanDeclarator(DeclInfo *declinfo) {
if (
(declinfo->qual & ~(Q_ALIGNED_MASK | Q_OVERLOAD | Q_20000 | Q_PASCAL | Q_VOLATILE | Q_CONST)) ||
- (declinfo->storageclass == OBJECT_SCLASS_104 && (declinfo->qual & ~(Q_ALIGNED_MASK | Q_REFERENCE | Q_PASCAL | Q_VOLATILE | Q_CONST)))
+ (declinfo->storageclass == TK_TYPEDEF && (declinfo->qual & ~(Q_ALIGNED_MASK | Q_REFERENCE | Q_PASCAL | Q_VOLATILE | Q_CONST)))
)
CError_Error(176);
}
@@ -2000,8 +1966,7 @@ void scandeclaratorlist(DeclInfo *declinfo) {
}
CScope_GetScope(&savescope);
-#line 2707
- CError_ASSERT(declinfo->thetype);
+ CError_ASSERT(2707, declinfo->thetype);
r28 = 1;
while (1) {
@@ -2020,7 +1985,7 @@ void scandeclaratorlist(DeclInfo *declinfo) {
break;
}
- if (declinfo->storageclass != OBJECT_SCLASS_104) {
+ if (declinfo->storageclass != TK_TYPEDEF) {
if (IS_TYPE_FUNC(declinfo->thetype)) {
if (!CDecl_FunctionDeclarator(declinfo, NULL, r28, 1))
return;
@@ -2282,8 +2247,7 @@ static TypeEnum *CDecl_OldParseEnumList(TypeEnum *tenum, HashNameNode *name) {
CError_Error(154);
break;
default:
-#line 3071
- CError_FATAL();
+ CError_FATAL(3071);
}
} else {
switch (basetype->size) {
@@ -2307,8 +2271,7 @@ static TypeEnum *CDecl_OldParseEnumList(TypeEnum *tenum, HashNameNode *name) {
case 8:
break;
default:
-#line 3099
- CError_FATAL();
+ CError_FATAL(3099);
}
}
@@ -2378,9 +2341,6 @@ void CDecl_ComputeUnderlyingEnumType(TypeEnum *tenum) {
ObjEnumConst *oec2;
Type *r26;
int t;
- CInt64 maximumU;
- CInt64 unused;
- CInt64 minimum, maximum;
if (!copts.enumsalwaysint) {
for (oec2 = tenum->enumlist; oec2; oec2 = oec2->next) {
@@ -2389,9 +2349,9 @@ void CDecl_ComputeUnderlyingEnumType(TypeEnum *tenum) {
}
if (oec2) {
- unused = cint64_zero;
- minimum = cint64_zero;
- maximum = cint64_zero;
+ CInt64 unused = cint64_zero;
+ CInt64 minimum = cint64_zero;
+ CInt64 maximum = cint64_zero;
for (oec = tenum->enumlist; oec; oec = oec->next) {
if (CInt64_IsNegative(&oec->val) && !is_unsigned(oec->type)) {
if (CInt64_Less(oec->val, minimum))
@@ -2420,11 +2380,11 @@ void CDecl_ComputeUnderlyingEnumType(TypeEnum *tenum) {
break;
} while (1);
} else {
- maximumU = cint64_zero;
+ CInt64 val = cint64_zero;
for (oec = tenum->enumlist; oec; oec = oec->next) {
- if (CInt64_GreaterU(oec->val, maximumU))
- maximumU = oec->val;
+ if (CInt64_GreaterU(oec->val, val))
+ val = oec->val;
}
t = 0;
@@ -2435,7 +2395,7 @@ void CDecl_ComputeUnderlyingEnumType(TypeEnum *tenum) {
CError_Error(154);
break;
}
- if (CInt64_IsInURange(maximumU, r26->size))
+ if (CInt64_IsInURange(val, r26->size))
break;
} while (1);
}
@@ -2691,18 +2651,17 @@ void scanenum(DeclInfo *declinfo) {
declinfo->thetype = TYPE(CDecl_ParseEnumList(NULL, name));
}
- if (cparamblkptr->browseOptions.recordEnums && declinfo->fileoffsetinfo.file->recordbrowseinfo)
+ if (cparamblkptr->browseOptions.recordEnums && declinfo->file->recordbrowseinfo)
CBrowse_NewEnum(
cscope_current,
TYPE_ENUM(declinfo->thetype)->enumname,
- declinfo->fileoffsetinfo.file,
- (CPrepFileInfo *) declinfo->fileoffsetinfo.tokenline,
- declinfo->fileoffsetinfo.tokenoffset,
+ declinfo->file,
+ declinfo->file2,
+ declinfo->x60,
CPrep_BrowserFileOffset());
return;
} else {
-#line 3851
- CError_ASSERT(!copts.cplusplus || tk != ';');
+ CError_ASSERT(3851, !copts.cplusplus || tk != ';');
tkidentifier = name;
}
}
@@ -2716,8 +2675,7 @@ void scanenum(DeclInfo *declinfo) {
declinfo->thetype = type;
return;
} else {
-#line 3865
- CError_ASSERT(pr.name_4);
+ CError_ASSERT(3865, pr.name_4);
if ((tk = lex()) == '{') {
declinfo->thetype = TYPE(CDecl_ParseEnumList(NULL, pr.name_4));
return;
@@ -2759,7 +2717,7 @@ void CDecl_ScanStructDeclarator(BigDeclInfo *bde) {
}
if ((!copts.ANSI_strict || copts.c9x) && !bde->declinfo2.thetype->size && IS_TYPE_ARRAY(bde->declinfo2.thetype)) {
- if (bde->declinfo2.storageclass != OBJECT_SCLASS_102 && bde->declinfo2.storageclass != OBJECT_SCLASS_104) {
+ if (bde->declinfo2.storageclass != TK_STATIC && bde->declinfo2.storageclass != TK_TYPEDEF) {
type = TYPE_POINTER(bde->declinfo2.thetype)->target;
while (IS_TYPE_ARRAY(type))
type = TYPE_POINTER(type)->target;
@@ -2771,7 +2729,7 @@ void CDecl_ScanStructDeclarator(BigDeclInfo *bde) {
}
}
} else {
- if (bde->declinfo2.storageclass != OBJECT_SCLASS_102 && bde->declinfo2.storageclass != OBJECT_SCLASS_104) {
+ if (bde->declinfo2.storageclass != TK_STATIC && bde->declinfo2.storageclass != TK_TYPEDEF) {
if (!IS_TYPE_FUNC(bde->declinfo2.thetype) && !IsCompleteType(bde->declinfo2.thetype))
return;
}
@@ -2885,8 +2843,7 @@ static void CDecl_LayoutStruct(TypeStruct *tstruct) {
r23 = 1;
if (!member->name) {
-#line 4064
- CError_ASSERT(IS_TYPE_STRUCT(member->type));
+ CError_ASSERT(4064, IS_TYPE_STRUCT(member->type));
innerbase = member->offset;
innermember = TYPE_STRUCT(member->type)->members;
r23 = 1;
@@ -3076,7 +3033,7 @@ void scanstruct(DeclInfo *declinfo, short structtype) {
HashNameNode *name;
TypeStruct typecopy;
Boolean add_to_browse;
- BrowseStruct bs;
+ GList gl;
SInt32 offset;
if (copts.cplusplus) {
@@ -3127,8 +3084,8 @@ void scanstruct(DeclInfo *declinfo, short structtype) {
type = (Type *) CDecl_DefineStruct(NULL, structtype);
}
- if ((add_to_browse = cparamblkptr->browseOptions.recordClasses && declinfo->fileoffsetinfo.file->recordbrowseinfo))
- CBrowse_BeginStruct(declinfo, TYPE_STRUCT(type), &bs);
+ if ((add_to_browse = cparamblkptr->browseOptions.recordClasses && declinfo->file->recordbrowseinfo))
+ CBrowse_BeginStruct(declinfo, TYPE_STRUCT(type), &gl);
typecopy = *TYPE_STRUCT(type);
tk = lex();
@@ -3137,7 +3094,7 @@ void scanstruct(DeclInfo *declinfo, short structtype) {
declinfo->thetype = type;
if (add_to_browse)
- CBrowse_EndStruct(offset, &bs);
+ CBrowse_EndStruct(offset, &gl);
}
static void InlineFunctionObject(Object *obj, TypeClass *tclass) {
@@ -3243,14 +3200,12 @@ static void CDecl_AddFunctionMember(DeclE *decle, TypeClass *tclass, DeclInfo *d
declinfo->thetype = (Type *) tfunc;
} else {
tfunc = TYPE_METHOD(declinfo->thetype);
-#line 4579
- CError_ASSERT(!tclass->sominfo);
+ CError_ASSERT(4579, !tclass->sominfo);
}
CDecl_ExtractClassExportFlags(declinfo, tclass->eflags);
-#line 4597
- CError_ASSERT(cscope_current == tclass->nspace);
+ CError_ASSERT(4597, cscope_current == tclass->nspace);
if (list) {
obj = CDecl_OverloadFunctionObject(list, declinfo, &outflag, flag4 ? OverloadMode1 : OverloadMode2, 0);
@@ -3491,7 +3446,7 @@ static void CDecl_ParseFriendDecl(TypeClass *tclass) {
InlineFunctionObject(obj, tclass);
} else {
if (!obj->sclass)
- obj->sclass = OBJECT_SCLASS_103;
+ obj->sclass = TK_EXTERN;
}
}
} else {
@@ -3535,8 +3490,7 @@ static ObjMemberVar *CDecl_InstanceDataDeclarator(DeclE *decle, TypeClass *tclas
case OT_TYPETAG:
break;
default:
-#line 4989
- CError_FATAL();
+ CError_FATAL(4989);
}
}
@@ -3628,7 +3582,7 @@ static void CDecl_ParseClassMembers(DeclE *decle, TypeClass *tclass, short mode)
}
}
- CTempl_Parse(tclass, access);
+ CTempl_Parse(TEMPL_CLASS(tclass), access);
tk = lex();
continue;
}
@@ -3716,7 +3670,7 @@ static void CDecl_ParseClassMembers(DeclE *decle, TypeClass *tclass, short mode)
scandeclarator(&bde.declinfo2);
if (IS_TYPE_FUNC(bde.declinfo2.thetype)) {
if (r17)
- bde.declinfo2.thetype = CTemplTool_ResolveMemberSelfRefs(tclass, bde.declinfo2.thetype, &bde.declinfo2.qual);
+ bde.declinfo2.thetype = CTemplTool_ResolveMemberSelfRefs(TEMPL_CLASS(tclass), bde.declinfo2.thetype, &bde.declinfo2.qual);
if (tclass->sominfo) {
if (TYPE_FUNC(bde.declinfo2.thetype)->args)
CError_Error(272);
@@ -3856,9 +3810,9 @@ static void CDecl_ParseClassMembers(DeclE *decle, TypeClass *tclass, short mode)
after_various_things:
switch (bde.declinfo.storageclass) {
case 0:
- case OBJECT_SCLASS_102:
- case OBJECT_SCLASS_104:
- case OBJECT_SCLASS_12B:
+ case TK_STATIC:
+ case TK_TYPEDEF:
+ case TK_MUTABLE:
break;
default:
CError_Error(177);
@@ -3869,11 +3823,11 @@ static void CDecl_ParseClassMembers(DeclE *decle, TypeClass *tclass, short mode)
while (1) {
CDecl_ScanStructDeclarator(&bde);
if (r17)
- bde.declinfo2.thetype = CTemplTool_ResolveMemberSelfRefs(tclass, bde.declinfo2.thetype, &bde.declinfo2.qual);
+ bde.declinfo2.thetype = CTemplTool_ResolveMemberSelfRefs(TEMPL_CLASS(tclass), bde.declinfo2.thetype, &bde.declinfo2.qual);
if (bde.declinfo2.nspace)
CError_Error(200);
if (bde.declinfo2.x3E) {
- if (bde.declinfo.storageclass == OBJECT_SCLASS_12B)
+ if (bde.declinfo.storageclass == TK_MUTABLE)
CError_QualifierCheck(Q_MUTABLE);
r19 = 0;
switch (bde.declinfo2.x3E) {
@@ -3888,7 +3842,7 @@ static void CDecl_ParseClassMembers(DeclE *decle, TypeClass *tclass, short mode)
r19 = 1;
break;
default:
- if (bde.declinfo2.storageclass == OBJECT_SCLASS_102)
+ if (bde.declinfo2.storageclass == TK_STATIC)
CError_Error(193);
if (tclass->sominfo)
CError_Error(193);
@@ -3908,11 +3862,11 @@ static void CDecl_ParseClassMembers(DeclE *decle, TypeClass *tclass, short mode)
if (bde.declinfo2.name == constructor_name_node || bde.declinfo2.name == destructor_name_node)
CError_Error(241);
switch (bde.declinfo2.storageclass) {
- case OBJECT_SCLASS_104:
+ case TK_TYPEDEF:
CError_QualifierCheck(bde.declinfo2.qual & Q_VIRTUAL);
CDecl_TypedefDeclarator(&bde.declinfo2);
break;
- case OBJECT_SCLASS_102:
+ case TK_STATIC:
CError_QualifierCheck(bde.declinfo2.qual & Q_VIRTUAL);
if (tclass->sominfo)
CError_Error(271);
@@ -3929,11 +3883,11 @@ static void CDecl_ParseClassMembers(DeclE *decle, TypeClass *tclass, short mode)
}
break;
case 0:
- case OBJECT_SCLASS_12B:
+ case TK_MUTABLE:
if (IS_TYPE_FUNC(bde.declinfo2.thetype)) {
if (bde.declinfo2.name == tclass->classname)
CError_Error(241);
- if (bde.declinfo.storageclass == OBJECT_SCLASS_12B)
+ if (bde.declinfo.storageclass == TK_MUTABLE)
CError_QualifierCheck(Q_MUTABLE);
bde.declinfo2.qual |= r21;
CDecl_AddFunctionMember(decle, tclass, &bde.declinfo2, access, 1, 0, 1, 0);
@@ -3941,7 +3895,7 @@ static void CDecl_ParseClassMembers(DeclE *decle, TypeClass *tclass, short mode)
CDecl_CompleteType(bde.declinfo2.thetype);
CanCreateObject(bde.declinfo2.thetype);
CError_QualifierCheck(bde.declinfo2.qual & (Q_VIRTUAL | Q_INLINE));
- if (bde.declinfo2.storageclass == OBJECT_SCLASS_12B)
+ if (bde.declinfo2.storageclass == TK_MUTABLE)
bde.declinfo2.qual |= Q_MUTABLE;
CDecl_InstanceDataDeclarator(decle, tclass, bde.declinfo2.thetype, bde.declinfo2.qual, bde.declinfo2.name, access);
}
@@ -4236,17 +4190,14 @@ static void CDecl_ParseBaseClassList(TypeClass *tclass, short mode, Boolean is_t
}
}
-static short getaccesstype(short a, short b, short c) {
- AccessType a1 = (AccessType) a;
- AccessType b1 = (AccessType) b;
- AccessType c1 = (AccessType) c;
-
- if (a1 == ACCESSNONE || b1 == ACCESSNONE || b1 == ACCESSPRIVATE)
+static short getaccesstype(AccessType a, AccessType b, AccessType c) {
+ if (a == ACCESSNONE || b == ACCESSNONE || b == ACCESSPRIVATE)
return ACCESSNONE;
- else if (c1 == ACCESSPUBLIC && a1 != ACCESSPUBLIC)
+
+ if (c == ACCESSPUBLIC && b != ACCESSPUBLIC)
return ACCESSNONE;
- else
- return ACCESSPUBLIC;
+
+ return ACCESSPUBLIC;
}
static TypeMethod *CDecl_MakeDefaultCtorType(TypeClass *tclass) {
@@ -4566,8 +4517,7 @@ static void CDecl_SetupClassLayout(DeclE *decle, TypeClass *tclass, ObjBase **ob
i = TYPE_METHOD(obj->type)->x1E;
if (i > 0) {
-#line 6363
- CError_ASSERT((i - 1) < decle->x8 && !objbuf[(int) (i - 1)]);
+ CError_ASSERT(6363, (i - 1) < decle->x8 && !objbuf[(int) (i - 1)]);
objbuf[(int) (i - 1)] = OBJ_BASE(obj);
index++;
if (obj->datatype != DVFUNC && !TYPE_METHOD(obj->type)->x26 && CClass_OverridesBaseMember(tclass, obj->name, obj))
@@ -4587,8 +4537,7 @@ static void CDecl_SetupClassLayout(DeclE *decle, TypeClass *tclass, ObjBase **ob
TYPE_FUNC(obj->type)->flags &= ~FUNC_FLAGS_8;
}
} else {
-#line 6412
- CError_ASSERT(i == 0);
+ CError_ASSERT(6412, i == 0);
}
if (!tclass->sominfo)
@@ -4609,19 +4558,16 @@ static void CDecl_SetupClassLayout(DeclE *decle, TypeClass *tclass, ObjBase **ob
if (!tclass->sominfo) {
for (i = 0, ivar = tclass->ivars; i < decle->x8; i++) {
if (!objbuf[i]) {
-#line 6449
- CError_ASSERT(ivar);
+ CError_ASSERT(6449, ivar);
objbuf[i] = OBJ_BASE(ivar);
ivar = ivar->next;
index++;
}
}
-#line 6455
- CError_ASSERT(ivar == NULL);
+ CError_ASSERT(6455, ivar == NULL);
}
-#line 6458
- CError_ASSERT(index == decle->x8);
+ CError_ASSERT(6458, index == decle->x8);
}
void CDecl_CompleteClass(DeclE *decle, TypeClass *tclass) {
@@ -4660,9 +4606,8 @@ TypeClass *CDecl_DefineClass(NameSpace *nspace, HashNameNode *name, TypeClass *t
ObjType *objtype;
if (!tclass && nspace->theclass && (nspace->theclass->flags & CLASS_FLAGS_100)) {
-#line 6556
- CError_ASSERT(!flag2);
- return CTemplClass_DefineNestedClass(TEMPL_CLASS(nspace->theclass), name, mode);
+ CError_ASSERT(6556, !flag2);
+ return TYPE_CLASS(CTemplClass_DefineNestedClass(TEMPL_CLASS(nspace->theclass), name, mode));
}
mynspace = CScope_NewListNameSpace(name, 1);
@@ -4759,7 +4704,7 @@ void CDecl_ParseClass(DeclInfo *declinfo, short mode, Boolean flag1, UInt8 class
NameSpace *nspace;
CScopeParseResult pr;
CScopeSave scopesave;
- BrowseStruct bs;
+ GList gl;
FileOffsetInfo offsetsave;
SInt32 offset;
Boolean is_templ;
@@ -4828,8 +4773,7 @@ void CDecl_ParseClass(DeclInfo *declinfo, short mode, Boolean flag1, UInt8 class
goto tagtype_search;
}
-#line 6786
- CError_ASSERT(pr.name_4);
+ CError_ASSERT(6786, pr.name_4);
tclass = CDecl_DefineClass(CScope_FindNonClassNonFunctionNS(cscope_current), pr.name_4, NULL, mode, 0, 1);
tclass->eflags |= class_declspec;
@@ -4865,8 +4809,7 @@ void CDecl_ParseClass(DeclInfo *declinfo, short mode, Boolean flag1, UInt8 class
TEMPL_CLASS_INST(tclass)->is_specialized = 1;
}
-#line 6853
- CError_ASSERT(copts.align_mode >= 0 && copts.align_mode <= 14);
+ CError_ASSERT(6853, copts.align_mode >= 0 && copts.align_mode <= 14);
tclass->eflags |= (UInt8) ((copts.align_mode + 1) << 4);
if (tk == ':')
@@ -4875,9 +4818,9 @@ void CDecl_ParseClass(DeclInfo *declinfo, short mode, Boolean flag1, UInt8 class
CScope_SetClassDefScope(tclass, &scopesave);
if (tk == '{') {
tk = lex();
- if ((add_to_browse = cparamblkptr->browseOptions.recordClasses && declinfo->fileoffsetinfo.file->recordbrowseinfo)) {
+ if ((add_to_browse = cparamblkptr->browseOptions.recordClasses && declinfo->file->recordbrowseinfo)) {
offsetsave = member_fileoffset;
- CBrowse_BeginClass(declinfo, &bs);
+ CBrowse_BeginClass(declinfo, &gl);
}
CDecl_ParseClassMembers(&decle, tclass, mode);
offset = CPrep_BrowserFileOffset();
@@ -4887,7 +4830,7 @@ void CDecl_ParseClass(DeclInfo *declinfo, short mode, Boolean flag1, UInt8 class
member_fileoffset = offsetsave;
if (flag1 && tk == ';')
CPrep_BrowserFileOffset();
- CBrowse_EndClass(offset, &bs);
+ CBrowse_EndClass(offset, &gl);
}
} else {
CError_Error(135);
diff --git a/compiler_and_linker/unsorted/CError.c b/compiler_and_linker/unsorted/CError.c
index 40e237a..a7ade45 100644
--- a/compiler_and_linker/unsorted/CError.c
+++ b/compiler_and_linker/unsorted/CError.c
@@ -249,7 +249,6 @@ void CError_BufferAppendTemplDepType(CErrorBuffer *eb, TypeTemplDep *type) {
}
void CError_BufferAppendFuncArgs(CErrorBuffer *eb, TypeFunc *tfunc, Boolean isMethod) {
- // not matching - weirdness with referencing string constants
FuncArg *arg;
UInt32 qual;
@@ -274,14 +273,14 @@ void CError_BufferAppendFuncArgs(CErrorBuffer *eb, TypeFunc *tfunc, Boolean isMe
if (arg == &elipsis || arg == &oldstyle) {
CError_BufferAppendString(eb, "...");
break;
- } else {
- CError_BufferAppendType(eb, arg->type, arg->qual);
}
- if (!arg->next) {
+ CError_BufferAppendType(eb, arg->type, arg->qual);
+
+ if ((arg = arg->next))
CError_BufferAppendString(eb, ", ");
+ else
break;
- }
}
}
CError_BufferAppendChar(eb, ')');
@@ -291,73 +290,73 @@ void CError_BufferAppendFuncArgs(CErrorBuffer *eb, TypeFunc *tfunc, Boolean isMe
void CError_BufferAppendType(CErrorBuffer *eb, Type *ty, UInt32 qual) {
// not matching - register issues
+ Type *scan;
+ Type *scan2;
char buf[16];
- Type *scan, *scan2;
switch (ty->type) {
case TYPEVOID:
CError_BufferAppendQualifier(eb, qual);
CError_BufferAppendString(eb, "void");
- break;
+ return;
case TYPEINT:
case TYPEFLOAT:
CError_BufferAppendQualifier(eb, qual);
switch (TYPE_INTEGRAL(ty)->integral) {
case IT_BOOL:
CError_BufferAppendString(eb, "bool");
- break;
+ return;
case IT_CHAR:
CError_BufferAppendString(eb, "char");
- break;
+ return;
case IT_UCHAR:
CError_BufferAppendString(eb, "unsigned char");
- break;
+ return;
case IT_SCHAR:
CError_BufferAppendString(eb, "signed char");
- break;
+ return;
case IT_WCHAR_T:
CError_BufferAppendString(eb, "wchar_t");
- break;
+ return;
case IT_SHORT:
CError_BufferAppendString(eb, "short");
- break;
+ return;
case IT_USHORT:
CError_BufferAppendString(eb, "unsigned short");
- break;
+ return;
case IT_INT:
CError_BufferAppendString(eb, "int");
- break;
+ return;
case IT_UINT:
CError_BufferAppendString(eb, "unsigned int");
- break;
+ return;
case IT_LONG:
CError_BufferAppendString(eb, "long");
- break;
+ return;
case IT_ULONG:
CError_BufferAppendString(eb, "unsigned long");
- break;
+ return;
case IT_LONGLONG:
CError_BufferAppendString(eb, "long long");
- break;
+ return;
case IT_ULONGLONG:
CError_BufferAppendString(eb, "unsigned long long");
- break;
+ return;
case IT_FLOAT:
CError_BufferAppendString(eb, "float");
- break;
+ return;
case IT_SHORTDOUBLE:
CError_BufferAppendString(eb, "short double");
- break;
+ return;
case IT_DOUBLE:
CError_BufferAppendString(eb, "double");
- break;
+ return;
case IT_LONGDOUBLE:
CError_BufferAppendString(eb, "long double");
- break;
+ return;
default:
CError_FATAL(584);
}
- break;
case TYPEENUM:
CError_BufferAppendQualifier(eb, qual);
CError_BufferAppendNameSpace(eb, TYPE_ENUM(ty)->nspace);
@@ -365,7 +364,7 @@ void CError_BufferAppendType(CErrorBuffer *eb, Type *ty, UInt32 qual) {
CError_BufferAppendString(eb, TYPE_ENUM(ty)->enumname->name);
else
CError_BufferAppendString(eb, "{unnamed-enum}");
- break;
+ return;
case TYPESTRUCT:
CError_BufferAppendQualifier(eb, qual);
switch (TYPE_STRUCT(ty)->stype) {
@@ -373,7 +372,7 @@ void CError_BufferAppendType(CErrorBuffer *eb, Type *ty, UInt32 qual) {
CError_BufferAppendString(eb, "struct ");
break;
case STRUCT_TYPE_UNION:
- CError_BufferAppendString(eb, "struct ");
+ CError_BufferAppendString(eb, "union ");
break;
case STRUCT_TYPE_4:
case STRUCT_TYPE_5:
@@ -392,7 +391,7 @@ void CError_BufferAppendType(CErrorBuffer *eb, Type *ty, UInt32 qual) {
}
if (TYPE_STRUCT(ty)->name)
CError_BufferAppendString(eb, TYPE_STRUCT(ty)->name->name);
- break;
+ return;
case TYPECLASS:
CError_BufferAppendQualifier(eb, qual);
CError_BufferAppendNameSpace(eb, TYPE_CLASS(ty)->nspace->parent);
@@ -406,7 +405,7 @@ void CError_BufferAppendType(CErrorBuffer *eb, Type *ty, UInt32 qual) {
} else {
CError_BufferAppendString(eb, "{unnamed-class}");
}
- break;
+ return;
case TYPEPOINTER:
case TYPEMEMBERPOINTER:
scan = ty;
@@ -430,7 +429,7 @@ void CError_BufferAppendType(CErrorBuffer *eb, Type *ty, UInt32 qual) {
CError_BufferAppendPType(eb, ty);
CError_BufferAppendChar(eb, ')');
CError_BufferAppendFuncArgs(eb, TYPE_FUNC(scan), ty->type == TYPEMEMBERPOINTER);
- break;
+ return;
case TYPEARRAY:
scan2 = scan;
while (scan->type == TYPEARRAY)
@@ -445,7 +444,7 @@ void CError_BufferAppendType(CErrorBuffer *eb, Type *ty, UInt32 qual) {
CError_BufferAppendType(eb, scan, 0);
CError_BufferAppendChar(eb, ' ');
CError_BufferAppendPType(eb, ty);
- break;
+ return;
}
break;
case TYPEFUNC:
@@ -455,7 +454,7 @@ void CError_BufferAppendType(CErrorBuffer *eb, Type *ty, UInt32 qual) {
CError_BufferAppendType(eb, TYPE_FUNC(ty)->functype, 0);
CError_BufferAppendChar(eb, ' ');
CError_BufferAppendFuncArgs(eb, TYPE_FUNC(ty), 0);
- break;
+ return;
case TYPEARRAY:
CError_BufferAppendQualifier(eb, qual);
scan = ty;
@@ -472,18 +471,18 @@ void CError_BufferAppendType(CErrorBuffer *eb, Type *ty, UInt32 qual) {
CError_BufferAppendChar(eb, ']');
ty = TYPE_POINTER(ty)->target;
}
- break;
+ return;
case TYPETEMPLATE:
CError_BufferAppendQualifier(eb, qual);
CError_BufferAppendTemplDepType(eb, TYPE_TEMPLATE(ty));
- break;
+ return;
case TYPETEMPLDEPEXPR:
CError_BufferAppendString(eb, "T");
- break;
+ return;
case TYPEBITFIELD:
sprintf(buf, "bitfield:%ld", TYPE_BITFIELD(ty)->unkB);
CError_BufferAppendString(eb, buf);
- break;
+ return;
default:
CError_FATAL(752);
}
@@ -740,56 +739,58 @@ void CError_ErrorMessageVA(int code, const char *format, va_list list, Boolean f
SInt32 moddate;
Type *type;
UInt32 qual;
+ const char *p;
CError_BufferInit(&eb, buf, sizeof(buf));
+ p = format;
do {
- switch (format[0]) {
+ switch (p[0]) {
case 0:
break;
case '%':
- switch (format[1]) {
+ switch (p[1]) {
case 'n':
MWUnmangle(va_arg(list, const char *), unmangleBuf, sizeof(unmangleBuf));
CError_BufferAppendString(&eb, unmangleBuf);
- format += 2;
+ p += 2;
continue;
case 'u':
CError_BufferAppendString(&eb, va_arg(list, const char *));
- format += 2;
+ p += 2;
continue;
case 'o':
CError_AppendObjectName(&eb, va_arg(list, Object *));
- format += 2;
+ p += 2;
continue;
case 'm':
CError_AppendMethodName(&eb, va_arg(list, ObjCMethod *));
- format += 2;
+ p += 2;
continue;
case 't':
type = va_arg(list, Type *);
qual = va_arg(list, UInt32);
CError_BufferAppendType(&eb, type, qual);
- format += 2;
+ p += 2;
continue;
case '%':
CError_BufferAppendChar(&eb, '%');
- format += 2;
+ p += 2;
continue;
case 'i':
sprintf(unmangleBuf, "%ld", va_arg(list, SInt32));
CError_BufferAppendString(&eb, unmangleBuf);
- format += 2;
+ p += 2;
continue;
case 'f':
CError_BufferAppendString(&eb, CTool_GetPathName(va_arg(list, FSSpec *), &moddate)->name);
- format += 2;
+ p += 2;
continue;
default:
CError_FATAL(1174);
}
break;
default:
- CError_BufferAppendChar(&eb, *(format++));
+ CError_BufferAppendChar(&eb, *(p++));
continue;
}
break;
@@ -883,6 +884,8 @@ void CError_ErrorFuncCall(short code, NameSpaceObjectList *args, ENodeList *argN
CError_BufferAppendType(&eb, argscan->node->rtype, argscan->node->flags & ENODE_FLAG_QUALS);
if ((argscan = argscan->next))
CError_BufferAppendString(&eb, ", ");
+ else
+ break;
}
CError_BufferAppendChar(&eb, ')');
break;
@@ -964,15 +967,11 @@ void CError_AbstractClassError(TypeClass *tclass) {
void CError_Warning(int code, ...) {
va_list va;
- if (trychain)
+ if (trychain || copts.supress_warnings)
return;
- if (copts.supress_warnings) {
- va_start(va, code);
- } else {
- va_start(va, code);
- CError_VAErrorMessage(code, va, 0, 1);
- }
+ va_start(va, code);
+ CError_VAErrorMessage(code, va, 0, 1);
va_end(va);
}
diff --git a/compiler_and_linker/unsorted/CException.c b/compiler_and_linker/unsorted/CException.c
index 2fdd2d3..d8a100c 100644
--- a/compiler_and_linker/unsorted/CException.c
+++ b/compiler_and_linker/unsorted/CException.c
@@ -25,13 +25,6 @@ typedef struct UniqueObj {
SInt32 uniqueid;
} UniqueObj;
-typedef struct DtorTemp {
- struct DtorTemp *next;
- Object *object;
- Object *dtor;
- Object *temp;
-} DtorTemp;
-
ExceptionAction *cexcept_dobjstack;
Boolean cexcept_hasdobjects;
Boolean cexcept_magic;
@@ -311,7 +304,7 @@ ENode *CExcept_RegisterDestructorObject(Object *local, SInt32 offset, Object *dt
cexcept_dobjstack = action;
expr = create_objectrefnode(local);
- dtorObject = CABI_GetDestructorObject(dtor, 1);
+ dtorObject = CABI_GetDestructorObject(dtor, CABIDestroy1);
if (offset == 0) {
action->type = EAT_DESTROYLOCAL;
@@ -339,7 +332,7 @@ void CExcept_RegisterLocalArray(Statement *stmt, Object *localarray, Object *dto
action->prev = cexcept_dobjstack;
cexcept_dobjstack = action;
- dtorObject = CABI_GetDestructorObject(dtor, 1);
+ dtorObject = CABI_GetDestructorObject(dtor, CABIDestroy1);
action->type = EAT_DESTROYLOCALARRAY;
action->data.destroy_local_array.localarray = localarray;
@@ -493,10 +486,10 @@ void CExcept_RegisterMember(Statement *stmt, Object *objectptr, SInt32 offset, O
if (cond == NULL) {
if (isMember) {
action->type = EAT_DESTROYMEMBER;
- action->data.destroy_member.dtor = CABI_GetDestructorObject(dtor, 1);
+ action->data.destroy_member.dtor = CABI_GetDestructorObject(dtor, CABIDestroy1);
} else {
action->type = EAT_DESTROYBASE;
- action->data.destroy_member.dtor = CABI_GetDestructorObject(dtor, 0);
+ action->data.destroy_member.dtor = CABI_GetDestructorObject(dtor, CABIDestroy0);
}
action->data.destroy_member.objectptr = objectptr;
action->data.destroy_member.offset = offset;
@@ -505,7 +498,7 @@ void CExcept_RegisterMember(Statement *stmt, Object *objectptr, SInt32 offset, O
action->type = EAT_DESTROYMEMBERCOND;
action->data.destroy_member_cond.objectptr = objectptr;
action->data.destroy_member_cond.cond = cond;
- action->data.destroy_member_cond.dtor = CABI_GetDestructorObject(dtor, 1);
+ action->data.destroy_member_cond.dtor = CABI_GetDestructorObject(dtor, CABIDestroy1);
action->data.destroy_member_cond.offset = offset;
}
@@ -521,7 +514,7 @@ void CExcept_RegisterMemberArray(Statement *stmt, Object *objectptr, SInt32 offs
action->type = EAT_DESTROYMEMBERARRAY;
action->data.destroy_member_array.objectptr = objectptr;
- action->data.destroy_member_array.dtor = CABI_GetDestructorObject(dtor, 1);
+ action->data.destroy_member_array.dtor = CABI_GetDestructorObject(dtor, CABIDestroy1);
action->data.destroy_member_array.offset = offset;
action->data.destroy_member_array.elements = elements;
action->data.destroy_member_array.element_size = element_size;
@@ -537,7 +530,7 @@ static Statement *CExcept_DestroyLocal(ExceptionAction *ea, Statement *stmt, Obj
if (offset)
expr = makediadicnode(expr, intconstnode(TYPE(&stunsignedlong), offset), EADD);
- expr = CABI_DestroyObject(dtor, expr, 1, 1, 0);
+ expr = CABI_DestroyObject(dtor, expr, CABIDestroy1, 1, 0);
CError_ASSERT(687, expr->type == EFUNCCALL && expr->data.funccall.funcref->type == EOBJREF);
if (expr->data.funccall.funcref->data.objref->datatype == DVFUNC)
@@ -565,7 +558,7 @@ static Statement *CExcept_DestroyLocalArray(ExceptionAction *ea, Statement *stmt
newStmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
if (dtor)
- dtorExpr = create_objectrefnode(CABI_GetDestructorObject(dtor, 1));
+ dtorExpr = create_objectrefnode(CABI_GetDestructorObject(dtor, CABIDestroy1));
else
dtorExpr = nullnode();
@@ -956,7 +949,7 @@ ENode *CExcept_ScanThrowExpression(void) {
Xthrw_func,
expr,
resultExpr,
- create_objectrefnode(CABI_GetDestructorObject(func, 1)),
+ create_objectrefnode(CABI_GetDestructorObject(func, CABIDestroy1)),
NULL);
} else {
expr = funccallexpr(
@@ -1318,7 +1311,7 @@ static ENode *CExcept_TempTrans_ETEMP(ENode *expr) {
cexcept_eabefore = ea;
ea->type = EAT_DESTROYLOCAL;
ea->data.destroy_local.local = dtorTemp->object;
- ea->data.destroy_local.dtor = CABI_GetDestructorObject(dtorTemp->dtor, 1);
+ ea->data.destroy_local.dtor = CABI_GetDestructorObject(dtorTemp->dtor, CABIDestroy1);
ea = lalloc(sizeof(ExceptionAction));
*ea = *cexcept_eabefore;
@@ -1635,7 +1628,7 @@ static ENode *CExcept_TempTransFuncCall(ENode *expr, Boolean isCond) {
ea->type = EAT_DESTROYLOCALCOND;
ea->data.destroy_local_cond.local = dtorTemp->object;
- ea->data.destroy_local_cond.dtor = CABI_GetDestructorObject(dtorTemp->dtor, 1);
+ ea->data.destroy_local_cond.dtor = CABI_GetDestructorObject(dtorTemp->dtor, CABIDestroy1);
ea->data.destroy_local_cond.cond = dtorTemp->temp;
ea = lalloc(sizeof(ExceptionAction));
@@ -1653,7 +1646,7 @@ static ENode *CExcept_TempTransFuncCall(ENode *expr, Boolean isCond) {
ea->type = EAT_DESTROYLOCAL;
ea->data.destroy_local.local = dtorTemp->object;
- ea->data.destroy_local.dtor = CABI_GetDestructorObject(dtorTemp->dtor, 1);
+ ea->data.destroy_local.dtor = CABI_GetDestructorObject(dtorTemp->dtor, CABIDestroy1);
ea = lalloc(sizeof(ExceptionAction));
*ea = *cexcept_eabefore;
@@ -1896,7 +1889,7 @@ static Statement *CExcept_DtorTransform(Statement *stmt) {
}
curStmt = CFunc_InsertStatement(ST_EXPRESSION, curStmt);
- curStmt->expr = CABI_DestroyObject(dtorTemp->dtor, create_objectrefnode(dtorTemp->object), 1, 1, 0);
+ curStmt->expr = CABI_DestroyObject(dtorTemp->dtor, create_objectrefnode(dtorTemp->object), CABIDestroy1, 1, 0);
curStmt->dobjstack = cexcept_eaafter;
if (dtorTemp->temp) {
diff --git a/compiler_and_linker/unsorted/CExpr.c b/compiler_and_linker/unsorted/CExpr.c
index 425a004..f305fc9 100644
--- a/compiler_and_linker/unsorted/CExpr.c
+++ b/compiler_and_linker/unsorted/CExpr.c
@@ -3,16 +3,25 @@
#include "compiler/CClass.h"
#include "compiler/CDecl.h"
#include "compiler/CError.h"
+#include "compiler/CException.h"
#include "compiler/CInit.h"
#include "compiler/CInline.h"
+#include "compiler/CIRTransform.h"
#include "compiler/CMachine.h"
#include "compiler/CMangler.h"
#include "compiler/CInt64.h"
+#include "compiler/CObjC.h"
+#include "compiler/CObjCModern.h"
#include "compiler/CParser.h"
#include "compiler/CPrep.h"
#include "compiler/CPrepTokenizer.h"
+#include "compiler/CRTTI.h"
+#include "compiler/CSOM.h"
+#include "compiler/CTemplateNew.h"
+#include "compiler/CTemplateTools.h"
#include "compiler/CodeGen.h"
#include "compiler/CompilerTools.h"
+#include "compiler/PPCError.h"
#include "compiler/objects.h"
#include "compiler/scopes.h"
#include "compiler/templates.h"
@@ -20,30 +29,6 @@
Boolean (*name_obj_check)(HashNameNode *, Object *);
Boolean disallowgreaterthan;
-// MOVE ME
-extern ENode *CIRTrans_TransformOpAss(ENode *);
-extern ENode *CTempl_MakeTemplDepExpr(ENode *, ENodeType, ENode *);
-extern Boolean CTemplTool_IsTemplateArgumentDependentType(Type *type);
-extern Boolean CTemplTool_IsTemplateArgumentDependentExpression(ENode *expr);
-extern ENode *CSOM_MemberVarAccess(BClassList *path, ObjMemberVar *var, ENode *expr);
-extern TemplArg *CTempl_ParseUncheckTemplArgs(void *a, Boolean flag);
-extern Boolean CObjC_IsCompatibleType(Type *a, Type *b);
-extern Type *CObjC_GetObjCType_id(Boolean flag);
-extern ENode *CExcept_ScanThrowExpression(void);
-extern void PPCError_Error(int code, ...);
-extern ENode *CObjC_ParseSelectorExpression(void);
-extern ENode *CObjC_ParseEncodeExpression(void);
-extern ENode *CObjC_ParseProtocolExpression(void);
-extern ENode *CObjC_ParseAtExpression(void);
-extern ENode *CObjC_ParseMessageExpression(void);
-extern ENode *CRTTI_Parse_const_cast(void);
-extern ENode *CRTTI_Parse_dynamic_cast(void);
-extern ENode *CRTTI_Parse_reinterpret_cast(void);
-extern ENode *CRTTI_Parse_static_cast(void);
-extern ENode *CRTTI_ParseTypeID(void);
-extern Boolean CObjC_IsType_id(Type *type);
-extern ENode *CObjC_CheckModernSendMessage(Type *type, ENode *expr);
-
// forward declarations
static ENode *makeaddnode(ENode *left, ENode *right);
static ENode *makesubnode(ENode *left, ENode *right);
@@ -81,8 +66,7 @@ restart:
expr->data.floatval = CMach_CalcFloatConvertFromInt(TYPE(&stsignedlong), cint64_zero);
break;
default:
-#line 105
- CError_FATAL();
+ CError_FATAL(105);
}
}
}
@@ -383,8 +367,7 @@ static ENode *integralpointerpromote(ENode *expr) {
} else if (stunsignedint.size == 4) {
type = TYPE(&stunsignedint);
} else {
-#line 480
- CError_FATAL();
+ CError_FATAL(480);
}
} else {
if (stsignedlong.size == 4) {
@@ -392,8 +375,7 @@ static ENode *integralpointerpromote(ENode *expr) {
} else if (stsignedint.size == 4) {
type = TYPE(&stsignedint);
} else {
-#line 486
- CError_FATAL();
+ CError_FATAL(486);
}
}
}
@@ -865,8 +847,7 @@ static ENode *CExpr_MemberVarAccess(BClassList *path, ObjMemberVar *var, ENode *
ENode *accessnode;
BClassList *varpath;
-#line 1152
- CError_ASSERT(path);
+ CError_ASSERT(1152, path);
if (TYPE_CLASS(path->type)->sominfo)
return CSOM_MemberVarAccess(path, var, expr);
@@ -952,8 +933,7 @@ ENode *CExpr_MakeNameLookupResultExpr(CScopeParseResult *pr) {
CError_Error(0xDD);
return nullnode();
default:
-#line 1268
- CError_FATAL();
+ CError_FATAL(1268);
}
}
@@ -964,8 +944,7 @@ ENode *CExpr_MakeNameLookupResultExpr(CScopeParseResult *pr) {
return expr;
}
-#line 1278
- CError_FATAL();
+ CError_FATAL(1278);
return NULL;
}
@@ -987,19 +966,16 @@ static Type *CExpr_NewPTMType(EMemberInfo *member, Object *obj) {
ptm->ty1 = OBJ_MEMBER_VAR(member->list->object)->type;
} else {
if (!obj) {
-#line 1306
- CError_ASSERT(member->list->object->otype == OT_OBJECT);
+ CError_ASSERT(1306, member->list->object->otype == OT_OBJECT);
obj = OBJECT(member->list->object);
-#line 1308
- CError_ASSERT(IS_TYPE_FUNC(obj->type));
+ CError_ASSERT(1308, IS_TYPE_FUNC(obj->type));
}
tmethod = galloc(sizeof(TypeMethod));
memclrw(tmethod, sizeof(TypeMethod));
*tmethod = *TYPE_METHOD(obj->type);
-#line 1312
- CError_ASSERT(tmethod->args);
+ CError_ASSERT(1312, tmethod->args);
tmethod->args = tmethod->args->next;
CDecl_MakePTMFuncType(TYPE_FUNC(tmethod));
@@ -1139,8 +1115,7 @@ static ENode *CExpr_ParseNameResultExpr(CScopeParseResult *pr, ENode *expr, Bool
val++;
}
if (act->u.enumerator.objenumconst == oec) {
-#line 1521
- CError_ASSERT(expr);
+ CError_ASSERT(1521, expr);
expr = CInline_CopyExpression(expr, CopyMode0);
if (val)
expr = makediadicnode(expr, intconstnode(TYPE(&stsignedlong), val), EADD);
@@ -1168,8 +1143,7 @@ static ENode *CExpr_ParseNameResultExpr(CScopeParseResult *pr, ENode *expr, Bool
}
break;
default:
-#line 1552
- CError_FATAL();
+ CError_FATAL(1552);
}
member = lalloc(sizeof(EMemberInfo));
@@ -1179,8 +1153,7 @@ static ENode *CExpr_ParseNameResultExpr(CScopeParseResult *pr, ENode *expr, Bool
member->pr_1D = pr->x1D;
member->isambig = pr->isambig;
if ((tk = lex()) == '<' && (ta_expr = CExpr_ExplicitTemplateArgCheck(pr))) {
-#line 1564
- CError_ASSERT(ENODE_IS(ta_expr, EOBJLIST));
+ CError_ASSERT(1564, ENODE_IS(ta_expr, EOBJLIST));
member->list = ta_expr->data.objlist.list;
member->templargs = ta_expr->data.objlist.templargs;
} else {
@@ -1197,8 +1170,7 @@ static ENode *CExpr_ParseNameResultExpr(CScopeParseResult *pr, ENode *expr, Bool
if (pr->nsol_14) {
if ((tk = lex()) == '<' && (ta_expr = CExpr_ExplicitTemplateArgCheck(pr))) {
-#line 1591
- CError_ASSERT(ENODE_IS(ta_expr, EOBJLIST));
+ CError_ASSERT(1591, ENODE_IS(ta_expr, EOBJLIST));
for (list = ta_expr->data.objlist.list; list; list = list->next) {
if (list->object->otype == OT_OBJECT && IS_TYPE_NONSTATIC_METHOD(OBJECT(list->object)->type)) {
member = lalloc(sizeof(EMemberInfo));
@@ -1290,8 +1262,7 @@ static ENode *CExpr_ParseNameResultExpr(CScopeParseResult *pr, ENode *expr, Bool
return create_objectrefnode(obj);
}
-#line 1711
- CError_FATAL();
+ CError_FATAL(1711);
return NULL;
}
@@ -1462,8 +1433,7 @@ static SInt32 CExpr_AtomTypeID(IntegralType what) {
case IT_23: return 38;
case IT_24: return 39;
default:
-#line 1976
- CError_FATAL();
+ CError_FATAL(1976);
return 0;
}
}
@@ -1734,8 +1704,7 @@ static ENode *CExpr_NewPTMFCall(void) {
CError_Error(115);
return nullnode();
} else {
-#line 2465
- CError_FATAL();
+ CError_FATAL(2465);
return nullnode();
}
}
@@ -1770,8 +1739,7 @@ static ENode *call_ptmf(ENode *expr) {
list2->node = expr->data.mfpointer.mfpointer->data.monadic;
if (!copts.old_argmatch) {
-#line 2568
- CError_ASSERT(IS_TYPE_POINTER_ONLY(list2->node->rtype));
+ CError_ASSERT(2568, IS_TYPE_POINTER_ONLY(list2->node->rtype));
list2->node->rtype = TYPE(&void_ptr);
}
@@ -1938,9 +1906,8 @@ loop:
goto loop;
}
-#line 2753
- CError_ASSERT((expr = conv.left));
- CError_ASSERT((subexpr = conv.right));
+ CError_ASSERT(2753, expr = conv.left);
+ CError_ASSERT(2754, subexpr = conv.right);
}
if (IS_TYPE_POINTER(expr->rtype)) {
@@ -1964,8 +1931,7 @@ loop:
funcexpr = CExpr_PointerGeneration(expr);
if (copts.cplusplus) {
if (CExpr_CheckOperator('(', funcexpr, NULL, &conv)) {
-#line 2775
- CError_ASSERT((expr = conv.x0));
+ CError_ASSERT(2775, expr = conv.x0);
goto loop;
}
if (ENODE_IS(funcexpr, EMFPOINTER)) {
@@ -1996,8 +1962,7 @@ loop:
expr = pointer_generation(expr);
if (copts.cplusplus) {
while (IS_TYPE_CLASS(expr->rtype) && CExpr_CheckOperator(TK_ARROW, expr, NULL, &conv)) {
-#line 2810
- CError_ASSERT((subexpr = conv.x0));
+ CError_ASSERT(2810, subexpr = conv.x0);
expr = pointer_generation(subexpr);
}
}
@@ -2020,7 +1985,7 @@ loop:
expr = pointer_generation(expr);
if (IS_TYPE_CLASS(expr->rtype)) {
CDecl_CompleteType(expr->rtype);
- if (TYPE_CLASS(expr->rtype)->objcinfo && copts.cplusplus && (subexpr = CObjC_CheckModernSendMessage(expr->rtype, expr)))
+ if (TYPE_CLASS(expr->rtype)->objcinfo && copts.cplusplus && (subexpr = CObjC_CheckModernSendMessage(TYPE_CLASS(expr->rtype), expr)))
return subexpr;
if (!(TYPE_CLASS(expr->rtype)->flags & CLASS_FLAGS_2))
@@ -2100,8 +2065,7 @@ loop:
tk = lex();
goto loop;
}
-#line 2952
- CError_ASSERT((tmp = conv.left));
+ CError_ASSERT(2952, tmp = conv.left);
}
tmp = CExpr_LValue(tmp, 1, 1);
if (tmp->rtype == TYPE(&stbool)) {
@@ -2121,8 +2085,7 @@ loop:
tk = lex();
goto loop;
}
-#line 2976
- CError_ASSERT((tmp = conv.left));
+ CError_ASSERT(2976, tmp = conv.left);
}
tmp = CExpr_LValue(tmp, 1, 1);
checkadditive(tmp);
@@ -2320,8 +2283,7 @@ static ENode *CExpr_MakeStaticMemberList(NameSpaceObjectList *list) {
static ENode *CExpr_MakePTDM(ENode *expr) {
ENode *result;
-#line 3414
- CError_ASSERT(ENODE_IS(expr, EMEMBER) && expr->data.emember->list->object->otype == OT_MEMBERVAR);
+ CError_ASSERT(3414, ENODE_IS(expr, EMEMBER) && expr->data.emember->list->object->otype == OT_MEMBERVAR);
result = nullnode();
result->rtype = CExpr_NewPTMType(expr->data.emember, NULL);
@@ -2338,8 +2300,7 @@ ENode *getpointertomemberfunc(ENode *expr, Type *type, Boolean flag) {
OLinkList *olist;
SInt32 data[3];
-#line 3442
- CError_ASSERT(ENODE_IS(expr, EMEMBER));
+ CError_ASSERT(3442, ENODE_IS(expr, EMEMBER));
if (expr->data.emember->expr && !copts.cpp_extensions)
CError_Error(141);
@@ -2378,8 +2339,7 @@ ENode *getpointertomemberfunc(ENode *expr, Type *type, Boolean flag) {
while (obj->datatype == DALIAS)
obj = obj->u.alias.object;
-#line 3503
- CError_ASSERT(obj->otype == OT_OBJECT && IS_TYPE_NONSTATIC_METHOD(obj->type));
+ CError_ASSERT(3503, obj->otype == OT_OBJECT && IS_TYPE_NONSTATIC_METHOD(obj->type));
if (TYPE_FUNC(obj->type)->flags & FUNC_FLAGS_100000)
CError_Error(190);
@@ -2414,8 +2374,7 @@ ENode *getpointertomemberfunc(ENode *expr, Type *type, Boolean flag) {
}
static ENode *getpointertomember(ENode *expr) {
-#line 3554
- CError_ASSERT(ENODE_IS(expr, EMEMBER));
+ CError_ASSERT(3554, ENODE_IS(expr, EMEMBER));
if (expr->data.emember->expr)
CError_Error(141);
@@ -2442,8 +2401,7 @@ ENode *CExpr_New_ELOGNOT_Node(ENode *input) {
if (copts.cplusplus && CExpr_CheckOperator('!', expr, NULL, &conv)) {
if ((input = conv.x0))
return input;
-#line 3593
- CError_ASSERT((expr = conv.left));
+ CError_ASSERT(3593, expr = conv.left);
}
switch (expr->rtype->type) {
@@ -2489,8 +2447,7 @@ ENode *CExpr_New_EMONMIN_Node(ENode *input) {
if (copts.cplusplus && CExpr_CheckOperator('-', expr, NULL, &conv)) {
if ((input = conv.x0))
return input;
-#line 3652
- CError_ASSERT((expr = conv.left));
+ CError_ASSERT(3652, expr = conv.left);
}
switch (expr->rtype->type) {
@@ -2525,8 +2482,7 @@ ENode *CExpr_New_EBINNOT_Node(ENode *input) {
if (copts.cplusplus && CExpr_CheckOperator('~', expr, NULL, &conv)) {
if ((input = conv.x0))
return input;
-#line 3702
- CError_ASSERT((expr = conv.left));
+ CError_ASSERT(3702, expr = conv.left);
}
expr = integralpromote(expr);
@@ -2566,8 +2522,7 @@ ENode *unary_expression(void) {
if (CExpr_CheckOperator(TK_INCREMENT, expr, NULL, &conv)) {
if (conv.x0)
return conv.x0;
-#line 3748
- CError_ASSERT((expr = conv.left));
+ CError_ASSERT(3748, expr = conv.left);
}
} else {
expr = pointer_generation(unary_expression());
@@ -2589,8 +2544,7 @@ ENode *unary_expression(void) {
if (CExpr_CheckOperator(TK_DECREMENT, expr, NULL, &conv)) {
if (conv.x0)
return conv.x0;
-#line 3776
- CError_ASSERT((expr = conv.left));
+ CError_ASSERT(3776, expr = conv.left);
}
} else {
expr = pointer_generation(unary_expression());
@@ -2614,8 +2568,7 @@ ENode *unary_expression(void) {
}
if (CExpr_CheckOperator('&', expr, NULL, &conv)) {
-#line 3809
- CError_ASSERT(conv.x0);
+ CError_ASSERT(3809, conv.x0);
return conv.x0;
}
} else {
@@ -2642,8 +2595,7 @@ ENode *unary_expression(void) {
if (copts.cplusplus && CExpr_CheckOperator('*', expr, NULL, &conv)) {
if (conv.x0)
return conv.x0;
-#line 3840
- CError_ASSERT((expr = conv.left));
+ CError_ASSERT(3840, expr = conv.left);
}
if (!IS_TYPE_POINTER(expr->rtype)) {
@@ -2661,8 +2613,7 @@ ENode *unary_expression(void) {
if (copts.cplusplus && CExpr_CheckOperator('+', expr, NULL, &conv)) {
if (conv.x0)
return conv.x0;
-#line 3852
- CError_ASSERT((expr = conv.left));
+ CError_ASSERT(3852, expr = conv.left);
}
switch (expr->rtype->type) {
@@ -2761,10 +2712,8 @@ ENode *PointerToMemberCast(ENode *expr, TypeMemberPointer *tm1, TypeMemberPointe
CInt64 pathoffset64;
ENode *tmp;
-#line 3984
- CError_ASSERT(IS_TYPE_CLASS(tm1->ty2));
-#line 3985
- CError_ASSERT(IS_TYPE_CLASS(tm2->ty2));
+ CError_ASSERT(3984, IS_TYPE_CLASS(tm1->ty2));
+ CError_ASSERT(3985, IS_TYPE_CLASS(tm2->ty2));
if (tm1->ty2 == tm2->ty2) {
expr->rtype = TYPE(tm2);
@@ -3113,8 +3062,7 @@ restart:
right = pointer_generation(cast_expression());
if (CExpr_CheckOperator(TK_ARROW_STAR, left, right, &conv)) {
-#line 4457
- CError_ASSERT((left = conv.x0));
+ CError_ASSERT(4457, left = conv.x0);
goto restart;
}
@@ -3192,8 +3140,7 @@ restart:
left = checkreference(left);
goto restart;
} else {
-#line 4535
- CError_ASSERT(ENODE_IS(right, EINDIRECT));
+ CError_ASSERT(4535, ENODE_IS(right, EINDIRECT));
tmp = lalloc(sizeof(ENode));
tmp->type = EMFPOINTER;
tmp->cost = 4;
@@ -3219,9 +3166,8 @@ ENode *CExpr_New_EMUL_Node(ENode *left, ENode *right) {
if (copts.cplusplus && CExpr_CheckOperator('*', left, right, &conv)) {
if (conv.x0)
return conv.x0;
-#line 4566
- CError_ASSERT((left = conv.left));
- CError_ASSERT((right = conv.right));
+ CError_ASSERT(4566, left = conv.left);
+ CError_ASSERT(4567, right = conv.right);
}
return makemultnode(left, right);
@@ -3238,9 +3184,8 @@ ENode *CExpr_New_EDIV_Node(ENode *left, ENode *right, Boolean no_warning) {
if (copts.cplusplus && CExpr_CheckOperator('/', left, right, &conv)) {
if (conv.x0)
return conv.x0;
-#line 4592
- CError_ASSERT((left = conv.left));
- CError_ASSERT((right = conv.right));
+ CError_ASSERT(4592, left = conv.left);
+ CError_ASSERT(4593, right = conv.right);
}
return makedivnode(left, right, no_warning);
@@ -3257,9 +3202,8 @@ ENode *CExpr_New_EMODULO_Node(ENode *left, ENode *right, Boolean no_warning) {
if (copts.cplusplus && CExpr_CheckOperator('%', left, right, &conv)) {
if (conv.x0)
return conv.x0;
-#line 4618
- CError_ASSERT((left = conv.left));
- CError_ASSERT((right = conv.right));
+ CError_ASSERT(4618, left = conv.left);
+ CError_ASSERT(4619, right = conv.right);
}
left = integralpromote(left);
@@ -3300,9 +3244,8 @@ ENode *CExpr_New_EADD_Node(ENode *left, ENode *right) {
if (copts.cplusplus && CExpr_CheckOperator('+', left, right, &conv)) {
if (conv.x0)
return conv.x0;
-#line 4665
- CError_ASSERT((left = conv.left));
- CError_ASSERT((right = conv.right));
+ CError_ASSERT(4665, left = conv.left);
+ CError_ASSERT(4666, right = conv.right);
}
return makeaddnode(left, right);
@@ -3319,9 +3262,8 @@ ENode *CExpr_New_ESUB_Node(ENode *left, ENode *right) {
if (copts.cplusplus && CExpr_CheckOperator('-', left, right, &conv)) {
if (conv.x0)
return conv.x0;
-#line 4690
- CError_ASSERT((left = conv.left));
- CError_ASSERT((right = conv.right));
+ CError_ASSERT(4690, left = conv.left);
+ CError_ASSERT(4691, right = conv.right);
}
return makesubnode(left, right);
@@ -3338,9 +3280,8 @@ ENode *CExpr_New_ESHL_Node(ENode *left, ENode *right) {
if (copts.cplusplus && CExpr_CheckOperator(TK_SHL, left, right, &conv)) {
if (conv.x0)
return conv.x0;
-#line 4715
- CError_ASSERT((left = conv.left));
- CError_ASSERT((right = conv.right));
+ CError_ASSERT(4715, left = conv.left);
+ CError_ASSERT(4716, right = conv.right);
}
left = integralpromote(left);
@@ -3369,9 +3310,8 @@ ENode *CExpr_New_ESHR_Node(ENode *left, ENode *right) {
if (copts.cplusplus && CExpr_CheckOperator(TK_SHR, left, right, &conv)) {
if (conv.x0)
return conv.x0;
-#line 4752
- CError_ASSERT((left = conv.left));
- CError_ASSERT((right = conv.right));
+ CError_ASSERT(4752, left = conv.left);
+ CError_ASSERT(4753, right = conv.right);
}
left = integralpromote(left);
@@ -3421,14 +3361,12 @@ static ENode *pointercompare(ENodeType nt, ENode *left, ENode *right) {
if (IS_TYPE_INT(ltype)) {
if (!(ENODE_IS(left, EINTCONST) && CInt64_IsZero(&left->data.intval)))
CError_Error(144);
-#line 4847
- CError_ASSERT(IS_TYPE_POINTER_ONLY(rtype));
+ CError_ASSERT(4847, IS_TYPE_POINTER_ONLY(rtype));
left->rtype = TYPE(&stunsignedlong);
} else if (IS_TYPE_INT(rtype)) {
if (!(ENODE_IS(right, EINTCONST) && CInt64_IsZero(&right->data.intval)))
CError_Error(144);
-#line 4855
- CError_ASSERT(IS_TYPE_POINTER_ONLY(ltype));
+ CError_ASSERT(4855, IS_TYPE_POINTER_ONLY(ltype));
right->rtype = TYPE(&stunsignedlong);
} else if (!is_typeequal(ltype, rtype)) {
CError_Error(245, left->rtype, ENODE_QUALS(left), right->rtype, ENODE_QUALS(right));
@@ -3473,9 +3411,8 @@ ENode *CExpr_New_ELESS_Node(ENode *left, ENode *right) {
if (copts.cplusplus && CExpr_CheckOperator('<', left, right, &conv)) {
if (conv.x0)
return conv.x0;
-#line 4929
- CError_ASSERT((left = conv.left));
- CError_ASSERT((right = conv.right));
+ CError_ASSERT(4929, left = conv.left);
+ CError_ASSERT(4930, right = conv.right);
}
if (IS_TYPE_POINTER(left->rtype) || IS_TYPE_POINTER(right->rtype))
@@ -3507,9 +3444,8 @@ ENode *CExpr_New_ELESSEQU_Node(ENode *left, ENode *right) {
if (copts.cplusplus && CExpr_CheckOperator(TK_LESS_EQUAL, left, right, &conv)) {
if (conv.x0)
return conv.x0;
-#line 4976
- CError_ASSERT((left = conv.left));
- CError_ASSERT((right = conv.right));
+ CError_ASSERT(4976, left = conv.left);
+ CError_ASSERT(4977, right = conv.right);
}
if (IS_TYPE_POINTER(left->rtype) || IS_TYPE_POINTER(right->rtype))
@@ -3541,9 +3477,8 @@ ENode *CExpr_New_EGREATER_Node(ENode *left, ENode *right) {
if (copts.cplusplus && CExpr_CheckOperator('>', left, right, &conv)) {
if (conv.x0)
return conv.x0;
-#line 5023
- CError_ASSERT((left = conv.left));
- CError_ASSERT((right = conv.right));
+ CError_ASSERT(5023, left = conv.left);
+ CError_ASSERT(5024, right = conv.right);
}
if (IS_TYPE_POINTER(left->rtype) || IS_TYPE_POINTER(right->rtype))
@@ -3575,9 +3510,8 @@ ENode *CExpr_New_EGREATEREQU_Node(ENode *left, ENode *right) {
if (copts.cplusplus && CExpr_CheckOperator(TK_GREATER_EQUAL, left, right, &conv)) {
if (conv.x0)
return conv.x0;
-#line 5070
- CError_ASSERT((left = conv.left));
- CError_ASSERT((right = conv.right));
+ CError_ASSERT(5070, left = conv.left);
+ CError_ASSERT(5071, right = conv.right);
}
if (IS_TYPE_POINTER(left->rtype) || IS_TYPE_POINTER(right->rtype))
@@ -3664,9 +3598,8 @@ ENode *CExpr_New_EEQU_Node(ENode *left, ENode *right) {
if (copts.cplusplus && CExpr_CheckOperator(TK_LOGICAL_EQ, left, right, &conv)) {
if (conv.x0)
return conv.x0;
-#line 5201
- CError_ASSERT((left = conv.left));
- CError_ASSERT((right = conv.right));
+ CError_ASSERT(5201, left = conv.left);
+ CError_ASSERT(5202, right = conv.right);
}
if (IS_TYPE_POINTER(left->rtype) || IS_TYPE_POINTER(right->rtype))
@@ -3702,9 +3635,8 @@ ENode *CExpr_New_ENOTEQU_Node(ENode *left, ENode *right) {
if (copts.cplusplus && CExpr_CheckOperator(TK_LOGICAL_NE, left, right, &conv)) {
if (conv.x0)
return conv.x0;
-#line 5261
- CError_ASSERT((left = conv.left));
- CError_ASSERT((right = conv.right));
+ CError_ASSERT(5261, left = conv.left);
+ CError_ASSERT(5262, right = conv.right);
}
if (IS_TYPE_POINTER(left->rtype) || IS_TYPE_POINTER(right->rtype))
@@ -3739,9 +3671,8 @@ ENode *CExpr_New_EAND_Node(ENode *left, ENode *right) {
if (copts.cplusplus && CExpr_CheckOperator('&', left, right, &conv)) {
if (conv.x0)
return conv.x0;
-#line 5321
- CError_ASSERT((left = conv.left));
- CError_ASSERT((right = conv.right));
+ CError_ASSERT(5321, left = conv.left);
+ CError_ASSERT(5322, right = conv.right);
}
left = integralpromote(left);
@@ -3774,9 +3705,8 @@ ENode *CExpr_New_EXOR_Node(ENode *left, ENode *right) {
if (copts.cplusplus && CExpr_CheckOperator('^', left, right, &conv)) {
if (conv.x0)
return conv.x0;
-#line 5360
- CError_ASSERT((left = conv.left));
- CError_ASSERT((right = conv.right));
+ CError_ASSERT(5360, left = conv.left);
+ CError_ASSERT(5361, right = conv.right);
}
left = integralpromote(left);
@@ -3809,9 +3739,8 @@ ENode *CExpr_New_EOR_Node(ENode *left, ENode *right) {
if (copts.cplusplus && CExpr_CheckOperator('|', left, right, &conv)) {
if (conv.x0)
return conv.x0;
-#line 5399
- CError_ASSERT((left = conv.left));
- CError_ASSERT((right = conv.right));
+ CError_ASSERT(5399, left = conv.left);
+ CError_ASSERT(5400, right = conv.right);
}
left = integralpromote(left);
@@ -3844,9 +3773,8 @@ ENode *CExpr_New_ELAND_Node(ENode *left, ENode *right) {
if (copts.cplusplus && CExpr_CheckOperator(TK_LOGICAL_AND, left, right, &conv)) {
if (conv.x0)
return conv.x0;
-#line 5438
- CError_ASSERT((left = conv.left));
- CError_ASSERT((right = conv.right));
+ CError_ASSERT(5438, left = conv.left);
+ CError_ASSERT(5439, right = conv.right);
}
switch (left->rtype->type) {
@@ -3930,9 +3858,8 @@ ENode *CExpr_New_ELOR_Node(ENode *left, ENode *right) {
if (copts.cplusplus && CExpr_CheckOperator(TK_LOGICAL_OR, left, right, &conv)) {
if (conv.x0)
return conv.x0;
-#line 5543
- CError_ASSERT((left = conv.left));
- CError_ASSERT((right = conv.right));
+ CError_ASSERT(5543, left = conv.left);
+ CError_ASSERT(5544, right = conv.right);
}
switch (left->rtype->type) {
@@ -4006,8 +3933,7 @@ ENode *CExpr_New_ELOR_Node(ENode *left, ENode *right) {
ENode *CExpr_NewDyadicNode(ENode *left, ENodeType nt, ENode *right) {
switch (nt) {
default:
-#line 5642
- CError_FATAL();
+ CError_FATAL(5642);
case EADD: return CExpr_New_EADD_Node(left, right);
case ESUB: return CExpr_New_ESUB_Node(left, right);
case EMUL: return CExpr_New_EMUL_Node(left, right);
@@ -4266,8 +4192,7 @@ ENode *CExpr_New_ECOND_Node(ENode *cond, ENode *expr1, ENode *expr2) {
if ((IS_TYPE_CLASS(expr1->rtype) || IS_TYPE_CLASS(expr2->rtype)) && !is_typesame(expr1->rtype, expr2->rtype)) {
if (!copts.old_argmatch) {
if (CExpr_CondOperatorMatch(expr1, expr2, &conv)) {
-#line 6246
- CError_ASSERT(!conv.x0);
+ CError_ASSERT(6246, !conv.x0);
expr1 = conv.left;
expr2 = conv.right;
} else if (CExpr_CanImplicitlyConvert(expr1, expr2->rtype, ENODE_QUALS(expr2))) {
@@ -4289,8 +4214,7 @@ ENode *CExpr_New_ECOND_Node(ENode *cond, ENode *expr1, ENode *expr2) {
args->next->next = NULL;
if (CExpr_CheckOperatorConversion(':', expr1, expr2, args, &conv)) {
-#line 6274
- CError_ASSERT(!conv.x0);
+ CError_ASSERT(6274, !conv.x0);
expr1 = conv.left;
expr2 = conv.right;
}
@@ -4479,8 +4403,7 @@ static ENode *makeassignmentnode(ENode *left, ENodeType nt, short token) {
if (!conv.x0) {
if (nt == EASS)
goto continue_anyway;
-#line 6531
- CError_FATAL();
+ CError_FATAL(6531);
}
return conv.x0;
}
@@ -4553,11 +4476,9 @@ continue_anyway:
case 1:
if ((args = args->next))
break;
-#line 6625
- CError_FATAL();
+ CError_FATAL(6625);
default:
-#line 6626
- CError_FATAL();
+ CError_FATAL(6626);
}
if (ENODE_IS(args->node, ETEMP)) {
if (!(IS_TYPE_CLASS(left->rtype) && CClass_Destructor(TYPE_CLASS(left->rtype)))) {
@@ -4583,8 +4504,7 @@ static ENode *makepassignmentnode(ENode *left, ENodeType nt, short token) {
tk = lex();
right = pointer_generation(assignment_expression());
if (CExpr_CheckOperator(token, left, right, &conv)) {
-#line 6669
- CError_ASSERT(conv.x0);
+ CError_ASSERT(6669, conv.x0);
return conv.x0;
}
left = CExpr_LValue(left, 1, 1);
@@ -4652,8 +4572,7 @@ static ENode *makemulassignmentnode(ENode *left, ENodeType nt, short token) {
tk = lex();
right = pointer_generation(assignment_expression());
if (CExpr_CheckOperator(token, left, right, &conv)) {
-#line 6753
- CError_ASSERT(conv.x0);
+ CError_ASSERT(6753, conv.x0);
return conv.x0;
}
if (!IS_TYPE_INT(left->rtype) && !(IS_TYPE_FLOAT(left->rtype) && nt != EMODASS)) {
@@ -4865,8 +4784,7 @@ static Boolean CExpr_HasSideEffect(ENode *expr) {
case EINSTRUCTION:
return 1;
default:
-#line 7056
- CError_FATAL();
+ CError_FATAL(7056);
return 0;
}
}
@@ -4911,11 +4829,9 @@ void CExpr_CheckUnusedExpression(ENode *expr) {
case 1:
if ((arg = arg->next))
break;
-#line 7110
- CError_FATAL();
+ CError_FATAL(7110);
default:
-#line 7111
- CError_FATAL();
+ CError_FATAL(7111);
}
if (!ENODE_IS(arg->node, ETEMP))
@@ -4938,8 +4854,7 @@ ENode *s_expression(void) {
right = pointer_generation(assignment_expression());
if (copts.cplusplus && CExpr_CheckOperator(',', left, right, &conv)) {
-#line 7143
- CError_ASSERT((left = conv.x0));
+ CError_ASSERT(7143, left = conv.x0);
} else {
CExpr_CheckUnusedExpression(left);
left = makecommaexpression(left, right);
@@ -4986,8 +4901,7 @@ ENode *CExpr_IntegralConstOrDepExpr(void) {
expr->rtype = TYPE_ENUM(expr->rtype)->enumtype;
return expr;
default:
-#line 7209
- CError_FATAL();
+ CError_FATAL(7209);
}
}
diff --git a/compiler_and_linker/unsorted/CExpr2.c b/compiler_and_linker/unsorted/CExpr2.c
index 67f4fb7..e2284d7 100644
--- a/compiler_and_linker/unsorted/CExpr2.c
+++ b/compiler_and_linker/unsorted/CExpr2.c
@@ -9,9 +9,14 @@
#include "compiler/CInline.h"
#include "compiler/CMachine.h"
#include "compiler/CMangler.h"
+#include "compiler/CObjC.h"
+#include "compiler/CObjCModern.h"
#include "compiler/CParser.h"
#include "compiler/CPrepTokenizer.h"
#include "compiler/CScope.h"
+#include "compiler/CSOM.h"
+#include "compiler/CTemplateFunc.h"
+#include "compiler/CTemplateTools.h"
#include "compiler/CodeGen.h"
#include "compiler/CompilerTools.h"
#include "compiler/enode.h"
@@ -28,21 +33,6 @@
#define va_arg(ap, type) (*(((type *) (ap = (char *)((((unsigned long)ap + __builtin_align(type) - 1) & ~(__builtin_align(type) - 1) ) + sizeof(type)))) - 1))
#endif
-// TODO MOVE ME
-extern ENode *CObjC_New(TypeClass *tclass);
-extern Boolean CObjC_IsType_id(Type *type);
-extern ENode *CObjC_Delete(TypeClass *tclass, ENode *expr);
-extern ENode *CSOM_New(TypeClass *tclass);
-extern ENode *CSOM_Delete(TypeClass *tclass, ENode *expr);
-extern ENode *CSOM_EnvCheck(ENode *, ENodeList *);
-extern ENode *CSOM_MethodAccess(BClassList *, Object *, Boolean);
-extern Boolean CTemplTool_IsTemplateArgumentDependentExpression(ENode *expr);
-extern ENode *CTemplTool_DeduceDefaultArg(Object *func, ENode *expr);
-extern Boolean CTempl_CanDeduceFunc(Object *func, TypeFunc *tfunc, TemplArg *templargs);
-extern void CTempl_FuncMatch(NameSpaceObjectList *nsol, TemplArg *templargs, ENodeList *argexprs, Match13 *match, ENode *expr);
-extern TemplFuncInstance *CTempl_DeduceFunc(Object *func, TypeFunc *tfunc, TemplArg *templargs, Object *anotherobj, Boolean flag);
-extern Boolean CObjC_IsCompatibleType(Type *a, Type *b);
-
ENode *assign_node;
Boolean temp_reference_init;
static SInt32 assign_value; // type?
@@ -172,8 +162,7 @@ restart:
CExpr_RecSearchExprTree(expr->data.itc.result);
return;
default:
-#line 128
- CError_FATAL();
+ CError_FATAL(128);
}
}
@@ -296,8 +285,7 @@ static ENode *CExpr_RecSearchExprTreeReplace(ENode *expr) {
expr->data.cond.expr2 = CExpr_RecSearchExprTreeReplace(expr->data.cond.expr2);
return expr;
default:
-#line 220
- CError_FATAL();
+ CError_FATAL(220);
return NULL;
}
}
@@ -557,13 +545,13 @@ ENode *CExpr_NewETEMPNode(Type *type, Boolean assign_id) {
static ENode *CExpr_DerefETEMPCopy(ENode *expr) {
ENode *copy;
-#line 636
- CError_ASSERT(expr->rtype->type == TYPEPOINTER);
+ CError_ASSERT(636, IS_TYPE_POINTER_ONLY(expr->rtype));
copy = lalloc(sizeof(ENode));
*copy = *expr;
copy = makemonadicnode(copy, EINDIRECT);
copy->rtype = TYPE_POINTER(copy->rtype)->target;
+ return copy;
}
ENode *CExpr_GetETEMPCopy(ENode *expr) {
@@ -682,8 +670,7 @@ void CExpr_ArithmeticConversion(ENode **left, ENode **right) {
if ((*left)->rtype == (Type *) &stsignedlong) {
*left = promote(*left, (Type *) &stunsignedlong);
} else {
-#line 838
- CError_ASSERT((*left)->rtype == (Type *) &stsignedlonglong);
+ CError_ASSERT(838, (*left)->rtype == (Type *) &stsignedlonglong);
*left = promote(*left, (Type *) &stunsignedlonglong);
}
}
@@ -742,14 +729,13 @@ static ENode *CExpr_GetEA(ENode *expr) {
}
ENode *CExpr_TempModifyExpr(ENode *expr) {
- // register issues
Type *type;
- ENode *tempnode;
- ENode *eanode;
- ENode *assnode2;
ENode *left;
ENode *right;
- ENode *work;
+ ENode *eanode;
+ ENode *tempnode;
+ ENode *indnode;
+ ENode *truenode;
type = expr->rtype;
tempnode = CExpr_NewETEMPNode(type, 1);
@@ -759,23 +745,24 @@ ENode *CExpr_TempModifyExpr(ENode *expr) {
return expr;
}
+ // tempnode = expr
left = makemonadicnode(tempnode, EINDIRECT);
left->rtype = type;
- work = makediadicnode(left, expr, EASS);
+ left = makediadicnode(left, expr, EASS);
- left = makemonadicnode(eanode, EINDIRECT);
- left->rtype = type;
- right = nullnode();
- right->rtype = (Type *) &stbool;
- CInt64_SetLong(&right->data.intval, 1);
- assnode2 = makediadicnode(left, right, EASS);
+ // eanode = true
+ indnode = makemonadicnode(eanode, EINDIRECT);
+ indnode->rtype = type;
+ truenode = nullnode();
+ truenode->rtype = (Type *) &stbool;
+ CInt64_SetLong(&truenode->data.intval, 1);
+ right = makediadicnode(indnode, truenode, EASS);
- work = makediadicnode(work, assnode2, ECOMMA);
- right = makemonadicnode(tempnode, EINDIRECT);
- right->rtype = type;
- work = makediadicnode(work, right, ECOMMA);
+ expr = makediadicnode(left, right, ECOMMA);
- return work;
+ indnode = makemonadicnode(tempnode, EINDIRECT);
+ indnode->rtype = type;
+ return makediadicnode(expr, indnode, ECOMMA);
}
Boolean CExpr_IsLValue(ENode *expr) {
@@ -924,7 +911,7 @@ loop:
ENode *CExpr_MakeObjRefNode(Object *obj, Boolean flag) {
ENode *expr;
- if (obj->sclass == OBJECT_SCLASS_104) {
+ if (obj->sclass == TK_TYPEDEF) {
CError_Error(141);
return intconstnode((Type *) &void_ptr, 0);
}
@@ -978,16 +965,20 @@ ENode *CExpr_IsTempConstruction(ENode *expr, Type *type, ENode **resultexpr) {
ENode *funccall;
ENode *funcref;
- if (!ENODE_IS(expr, EINDIRECT) || expr->rtype != type || !ENODE_IS((funccall = expr->data.monadic), EFUNCCALL) || !(args = funccall->data.funccall.args))
+ if (
+ !ENODE_IS(expr, EINDIRECT) ||
+ expr->rtype != type ||
+ !ENODE_IS((funccall = expr->data.monadic), EFUNCCALL) ||
+ !(args = funccall->data.funccall.args)
+ )
return NULL;
if (!ENODE_IS((funcref = funccall->data.funccall.funcref), EOBJREF) || !CClass_IsConstructor(funcref->data.objref)) {
if (expr->data.monadic->data.funccall.functype->functype != type)
return NULL;
- if (CABI_GetStructResultArgumentIndex() == 1) {
+ if (CABI_GetStructResultArgumentIndex(expr->data.monadic->data.funccall.functype) == 1) {
args = args->next;
-#line 1277
- CError_ASSERT(args);
+ CError_ASSERT(1277, args);
}
}
@@ -1040,8 +1031,7 @@ ENode *funccallexpr(Object *func, ENode *arg1, ENode *arg2, ENode *arg3, ENode *
ENodeList *list;
tfunc = TYPE_FUNC(func->type);
-#line 1411
- CError_ASSERT(IS_TYPE_FUNC(tfunc));
+ CError_ASSERT(1411, IS_TYPE_FUNC(tfunc));
expr = lalloc(sizeof(ENode));
expr->type = EFUNCCALL;
@@ -1084,8 +1074,7 @@ ENode *CExpr_FuncCallSix(Object *func, ENode *arg1, ENode *arg2, ENode *arg3, EN
ENodeList *list;
tfunc = TYPE_FUNC(func->type);
-#line 1460
- CError_ASSERT(IS_TYPE_FUNC(tfunc));
+ CError_ASSERT(1460, IS_TYPE_FUNC(tfunc));
expr = lalloc(sizeof(ENode));
expr->type = EFUNCCALL;
@@ -1134,8 +1123,7 @@ static void CExpr_CalcStdAssign(short checkresult, Match5 *match, Type *t1, UInt
match->x6 += assign_value;
break;
default:
-#line 1504
- CError_FATAL();
+ CError_FATAL(1504);
}
if (flag || (IS_TYPE_POINTER_ONLY(t2) && (IS_TYPE_POINTER_ONLY(t1) || IS_TYPEPOINTER_REFERENCE(TYPE_POINTER(t2))) != 0)) {
@@ -1197,8 +1185,7 @@ Boolean CExpr_MatchAssign(Type *type, UInt32 qual, ENode *expr, Match13 *match)
match->match5.x8 += user_std_match.x8;
break;
default:
-#line 1585
- CError_FATAL();
+ CError_FATAL(1585);
}
if (IS_TYPE_POINTER_ONLY(type))
@@ -1234,7 +1221,7 @@ static short CExpr2_MemberPointerConversion(Type *type, ENode *expr, Boolean fla
newnode = lalloc(sizeof(ENode));
*newnode = *expr;
if (!IS_TYPE_MEMBERPOINTER(newnode->rtype)) {
- newnode = CExpr_MemberPointerConversion(newnode, type, flag1);
+ newnode = CExpr_MemberPointerConversion(newnode, TYPE_MEMBER_POINTER(type), flag1);
if (iscpp_typeequal(newnode->rtype, type)) {
if (flag1)
assign_node = newnode;
@@ -1243,10 +1230,8 @@ static short CExpr2_MemberPointerConversion(Type *type, ENode *expr, Boolean fla
}
if (IS_TYPE_MEMBERPOINTER(newnode->rtype)) {
-#line 1656
- CError_ASSERT(IS_TYPE_CLASS(TYPE_MEMBER_POINTER(type)->ty2));
-#line 1657
- CError_ASSERT(IS_TYPE_CLASS(TYPE_MEMBER_POINTER(newnode->rtype)->ty2));
+ CError_ASSERT(1656, IS_TYPE_CLASS(TYPE_MEMBER_POINTER(type)->ty2));
+ CError_ASSERT(1657, IS_TYPE_CLASS(TYPE_MEMBER_POINTER(newnode->rtype)->ty2));
if (CClass_IsBaseClass(TYPE_CLASS(TYPE_MEMBER_POINTER(type)->ty2), TYPE_CLASS(TYPE_MEMBER_POINTER(newnode->rtype)->ty2), &depth, 0, 0)) {
assign_value = 1000 - depth;
@@ -1270,8 +1255,7 @@ ENode *CExpr_ClassPointerCast(BClassList *cls, ENode *origexpr, Boolean nullchec
expr = origexpr;
tclass = TYPE_CLASS(cls->type);
do_nullcheck = 0;
-#line 1691
- CError_ASSERT(cls);
+ CError_ASSERT(1691, cls);
if (!IS_TYPE_POINTER_ONLY(origexpr->rtype)) {
CError_Error(CErrorStr141);
@@ -1346,10 +1330,8 @@ ENode *CExpr_GetClassAccessNode(BClassList *a, BClassList *b, ENode *expr, Objec
expr->rtype = TYPE(cscope_currentclass);
}
-#line 1786
- CError_ASSERT(a);
-#line 1787
- CError_ASSERT(IS_TYPE_CLASS(expr->rtype));
+ CError_ASSERT(1786, a);
+ CError_ASSERT(1787, IS_TYPE_CLASS(expr->rtype));
tclass = TYPE_CLASS(expr->rtype);
a = CScope_GetClassAccessPath(a, tclass);
@@ -1411,8 +1393,7 @@ static short std_assign_check_overload(NameSpaceObjectList *list, TemplArg *temp
if (IS_TYPE_FUNC(obj->type) && (TYPE_FUNC(obj->type)->flags & FUNC_FLAGS_100000)) {
if (!found_non_template_func && CTempl_CanDeduceFunc(obj, TYPE_FUNC(type), templargs)) {
instance = CTempl_DeduceFunc(obj, TYPE_FUNC(type), templargs, NULL, 0);
-#line 1861
- CError_ASSERT(instance);
+ CError_ASSERT(1861, instance);
if (is_typesame(instance->object->type, type)) {
if (used_obj && used_obj != instance->object)
is_ambig = 1;
@@ -1458,7 +1439,7 @@ static short std_assign_check_overload(NameSpaceObjectList *list, TemplArg *temp
}
}
-ENode *CExpr_ConvertToBool(ENode *expr, Boolean flag) {
+ENode *CExpr_ConvertToBool(ENode *expr, Boolean isExplicit) {
if (IS_TYPE_MEMBERPOINTER(expr->rtype))
expr = CExpr_ConvertToCondition(expr);
@@ -1485,7 +1466,7 @@ ENode *CExpr_ConvertToBool(ENode *expr, Boolean flag) {
break;
default:
CError_Error(
- flag ? CErrorStr247 : CErrorStr209,
+ isExplicit ? CErrorStr247 : CErrorStr209,
expr->rtype,
expr->flags & ENODE_FLAG_QUALS,
&stbool,
@@ -1841,8 +1822,7 @@ short user_assign_check(ENode *expr, Type *type, UInt32 qual, Boolean flag1, Boo
UInt16 chk;
Boolean is_const, is_volatile;
-#line 2378
- CError_ASSERT(copts.old_argmatch);
+ CError_ASSERT(2378, copts.old_argmatch);
memclrw(&stdmatch, sizeof(Match5));
r24 = 0;
@@ -1872,8 +1852,7 @@ short user_assign_check(ENode *expr, Type *type, UInt32 qual, Boolean flag1, Boo
}
if ((result = std_assign_check(r14, type, 0, flag3))) {
CExpr_CalcStdAssign(result, &match_98, r17->functype, r17->qual, type, qual, 1);
-#line 2419
- CError_ASSERT(r17->args && IS_TYPE_POINTER_ONLY(r17->args->type));
+ CError_ASSERT(2419, r17->args && IS_TYPE_POINTER_ONLY(r17->args->type));
chk = expr->flags;
if (!(is_const = (r17->args->qual & Q_CONST)) && (chk & Q_CONST) != 0)
continue;
@@ -1976,8 +1955,7 @@ short user_assign_check(ENode *expr, Type *type, UInt32 qual, Boolean flag1, Boo
if (flag1) {
if (r24) {
r13 = TYPE_METHOD(r26->type);
-#line 2537
- CError_ASSERT(r13->flags & FUNC_FLAGS_METHOD);
+ CError_ASSERT(2537, r13->flags & FUNC_FLAGS_METHOD);
r15b = create_objectrefnode(r26);
r26->flags |= OBJECT_FLAGS_UNUSED;
r14d = lalloc(sizeof(ENodeList));
@@ -2092,8 +2070,7 @@ void CExpr_CheckArithmConversion(ENode *expr, Type *type) {
if (IS_TYPE_INT(expr->rtype)) {
if (IS_TYPE_FLOAT(type))
return;
-#line 2772
- CError_ASSERT(IS_TYPE_INT(type));
+ CError_ASSERT(2772, IS_TYPE_INT(type));
if (type->size > expr->rtype->size)
return;
@@ -2152,8 +2129,7 @@ ENode *get_address_of_temp_copy(ENode *expr, Boolean flag) {
innertype = TYPE(&stunsignedlong);
break;
default:
-#line 2857
- CError_FATAL();
+ CError_FATAL(2857);
}
CMach_InitIntMem(innertype, expr->data.intval, buf);
} else {
@@ -2440,8 +2416,7 @@ ENode *CExpr_GetDefaultArgument(ENode *funcexpr, FuncArg *arg) {
ENode *tmp;
if (CTemplTool_IsTemplateArgumentDependentExpression(arg->dexpr)) {
-#line 3264
- CError_ASSERT(ENODE_IS(funcexpr, EOBJREF));
+ CError_ASSERT(3264, ENODE_IS(funcexpr, EOBJREF));
tmp = CTemplTool_DeduceDefaultArg(
funcexpr->data.objref,
CInline_CopyExpression(arg->dexpr, CopyMode0)
@@ -2650,8 +2625,7 @@ ENode *CExpr_GenericFuncCall(BClassList *path, ENode *funcexpr, Boolean flag1, O
scan_arg = tfunc->args;
scan_expr = nodes;
if (tfunc->flags & FUNC_FLAGS_METHOD) {
-#line 3599
- CError_ASSERT(TYPE_METHOD(tfunc)->theclass->sominfo == NULL);
+ CError_ASSERT(3599, TYPE_METHOD(tfunc)->theclass->sominfo == NULL);
}
}
@@ -2883,8 +2857,7 @@ static Boolean accept_conversion_type(Type *type, short mode) {
case 3:
return IS_TYPE_POINTER_ONLY(type);
default:
-#line 3912
- CError_FATAL();
+ CError_FATAL(3912);
return 0;
}
}
@@ -3077,8 +3050,7 @@ static Boolean is_legal_type_combination(Type *left, Type *right, short mode) {
diadic_arg2.type = right;
return 1;
default:
-#line 4132
- CError_FATAL();
+ CError_FATAL(4132);
return 0;
}
}
@@ -3272,8 +3244,7 @@ Boolean CExpr_CheckOperator(short token, ENode *left, ENode *right, Conversion *
tk = lex();
return 1;
} else {
-#line 4371
- CError_FATAL();
+ CError_FATAL(4371);
}
}
return 0;
@@ -3320,8 +3291,7 @@ Boolean CExpr_CheckOperator(short token, ENode *left, ENode *right, Conversion *
tk = lex();
return 1;
} else {
-#line 4439
- CError_FATAL();
+ CError_FATAL(4439);
}
}
return 0;
@@ -3344,8 +3314,7 @@ Boolean CExpr_CheckOperator(short token, ENode *left, ENode *right, Conversion *
mylist_B0.object = pr2.obj_10;
pr2.nsol_14 = &mylist_B0;
} else {
-#line 4470
- CError_ASSERT(pr2.nsol_14);
+ CError_ASSERT(4470, pr2.nsol_14);
}
if (token != '=' || (pr2.bcl_18->type == left->rtype && pr2.bcl_18->next == NULL)) {
@@ -3406,15 +3375,13 @@ ENode *CExpr_ConstructObject(TypeClass *tclass, ENode *addr_expr, ENodeList *arg
NameSpaceObjectList *ctorlist;
BClassList path;
-#line 4595
- CError_ASSERT(IS_TYPE_POINTER_ONLY(addr_expr->rtype));
+ CError_ASSERT(4595, IS_TYPE_POINTER_ONLY(addr_expr->rtype));
addr_expr = makemonadicnode(addr_expr, EINDIRECT);
addr_expr->rtype = TYPE(tclass);
if (!flag3 && args && !args->next && args->node->rtype == TYPE(tclass) && !CClass_CopyConstructor(tclass)) {
-#line 4605
- CError_ASSERT(IS_TYPE_CLASS(addr_expr->rtype));
+ CError_ASSERT(4605, IS_TYPE_CLASS(addr_expr->rtype));
expr = makediadicnode(addr_expr, args->node, EASS);
if (!flag1)
expr = getnodeaddress(expr, 0);
@@ -3502,8 +3469,7 @@ static ENode *CExpr_CopyPlacementNewArg(ENodeList *list) {
switch (list->node->rtype->type) {
default:
-#line 4726
- CError_FATAL();
+ CError_FATAL(4726);
case TYPEINT:
case TYPEFLOAT:
case TYPEENUM:
@@ -3523,12 +3489,10 @@ static ENode *CExpr_PlacementDeleteCall(Type *type, ENode *expr, Object *obj, Bo
ENodeList *inputarg;
Boolean outflag;
-#line 4752
- CError_ASSERT(ENODE_IS(expr, EFUNCCALL) && ENODE_IS(expr->data.funccall.funcref, EOBJREF));
+ CError_ASSERT(4752, ENODE_IS(expr, EFUNCCALL) && ENODE_IS(expr->data.funccall.funcref, EOBJREF));
funcobj = expr->data.funccall.funcref->data.objref;
-#line 4756
- CError_ASSERT(IS_TYPE_FUNC(funcobj->type) && TYPE_FUNC(funcobj->type)->args && TYPE_FUNC(funcobj->type)->args->next);
+ CError_ASSERT(4756, IS_TYPE_FUNC(funcobj->type) && TYPE_FUNC(funcobj->type)->args && TYPE_FUNC(funcobj->type)->args->next);
funcobj = CParser_FindDeallocationObject(type, TYPE_FUNC(funcobj->type)->args->next, flag1, flag2, &outflag);
if (!funcobj)
@@ -3546,8 +3510,7 @@ static ENode *CExpr_PlacementDeleteCall(Type *type, ENode *expr, Object *obj, Bo
list->node = create_objectnode(obj);
result->data.funccall.args = list;
-#line 4780
- CError_ASSERT((inputarg = expr->data.funccall.args) && (inputarg = inputarg->next));
+ CError_ASSERT(4780, (inputarg = expr->data.funccall.args) && (inputarg = inputarg->next));
do {
list->next = lalloc(sizeof(ENodeList));
@@ -3688,12 +3651,10 @@ static ENode *CExpr_NewAlloc(Type *type, ENodeList *args, Boolean flag1, Boolean
if (CScope_FindClassMemberObject(TYPE_CLASS(type), &pr, name)) {
list = pr.nsol_14;
obj = OBJECT(pr.obj_10);
-#line 4935
- CError_ASSERT(list || obj);
+ CError_ASSERT(4935, list || obj);
found = 1;
} else if (TYPE_CLASS(type)->flags & CLASS_FLAGS_1) {
-#line 4942
- CError_ASSERT(!flag2);
+ CError_ASSERT(4942, !flag2);
obj = newh_func;
found = 1;
}
@@ -3764,8 +3725,7 @@ static ENode *CExpr_NewExceptionSafeInit(ENode *expr, ENode *tryexpr) {
expr->data.itc.tryexpr = tryexpr;
break;
default:
-#line 5056
- CError_FATAL();
+ CError_FATAL(5056);
}
return expr;
}
@@ -3834,7 +3794,7 @@ static ENode *CExpr_NewArray(Type *type, UInt32 qual, ENodeList *nodelist, Boole
dtor = CClass_Destructor(TYPE_CLASS(innertype));
if (dtor)
- dtor = CABI_GetDestructorObject(dtor, 1);
+ dtor = CABI_GetDestructorObject(dtor, CABIDestroy1);
ass = NULL;
if (firstarrayexpr) {
@@ -4223,8 +4183,7 @@ ENode *scandelete(Boolean flag) {
if (!flag) {
result_expr = CABI_DestroyObject(dtor, expr, 2, 0, 1);
} else {
-#line 5650
- CError_ASSERT(!outflag);
+ CError_ASSERT(5650, !outflag);
result_expr = CABI_DestroyObject(dtor, expr, 2, 0, 0);
result_expr->rtype = TYPE(&void_ptr);
result_expr = funccallexpr(obj, result_expr, NULL, NULL, NULL);
diff --git a/compiler_and_linker/unsorted/CExprConvMatch.c b/compiler_and_linker/unsorted/CExprConvMatch.c
index 9722dcb..7fdce02 100644
--- a/compiler_and_linker/unsorted/CExprConvMatch.c
+++ b/compiler_and_linker/unsorted/CExprConvMatch.c
@@ -1 +1,2518 @@
#include "compiler/CExpr.h"
+#include "compiler/CABI.h"
+#include "compiler/CClass.h"
+#include "compiler/CDecl.h"
+#include "compiler/CError.h"
+#include "compiler/CInt64.h"
+#include "compiler/CFunc.h"
+#include "compiler/CMachine.h"
+#include "compiler/CMangler.h"
+#include "compiler/CObjC.h"
+#include "compiler/CParser.h"
+#include "compiler/CScope.h"
+#include "compiler/CTemplateFunc.h"
+#include "compiler/CodeGen.h"
+#include "compiler/CompilerTools.h"
+#include "compiler/objects.h"
+#include "compiler/scopes.h"
+#include "compiler/templates.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+typedef struct StandardConv {
+ Type *type1;
+ Type *type2;
+ UInt32 qual1;
+ UInt32 qual2;
+ Boolean x10; // unknown
+ Boolean x11;
+ Boolean x12;
+ Boolean x13;
+ Boolean x14;
+ Boolean x15;
+} StandardConv;
+
+typedef enum EImplicitConvType {
+ ICT_0,
+ ICT_1,
+ ICT_2,
+ ICT_3
+} EImplicitConvType;
+
+typedef struct ImplicitConv {
+ EImplicitConvType type;
+ union {
+ struct {
+ Object *x2;
+ StandardConv standardConv;
+ } ic2;
+ struct {
+ StandardConv standardConv;
+ } ic3;
+ } u;
+} ImplicitConv;
+
+typedef struct ConversionTypeList {
+ struct ConversionTypeList *next;
+ Object *func;
+ Type *type;
+ UInt32 qual;
+} ConversionTypeList;
+
+typedef struct Match {
+ struct Match *next;
+ Object *object;
+ Object *specialfunc;
+ Type *type;
+ UInt32 qual;
+ Type *type2;
+ UInt32 qual2;
+ ImplicitConv conv[3];
+} Match;
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+// forward decls
+static ENode *CExpr_DerivedToBase(ENode *expr, Type *type2, UInt32 qual2, Boolean flag1, Boolean flag2, Boolean flag3);
+
+static Type *CExpr_GetImplictObjectParamType(Object *object, UInt32 *qual) {
+ Type *type;
+
+ CError_ASSERT(98, IS_TYPE_FUNC(object->type));
+ CError_ASSERT(99, TYPE_FUNC(object->type)->flags & FUNC_FLAGS_METHOD);
+ CError_ASSERT(100, !TYPE_METHOD(object->type)->x26);
+ CError_ASSERT(101, TYPE_METHOD(object->type)->args);
+
+ type = CDecl_NewRefPointerType(TYPE(TYPE_METHOD(object->type)->theclass));
+ *qual = TYPE_METHOD(object->type)->args->qual & Q_CV;
+ return type;
+}
+
+static Type *CExpr_GetParamType(Object *object, int index, UInt32 *qual) {
+ FuncArg *arg;
+
+ CError_ASSERT(120, IS_TYPE_FUNC(object->type));
+ CError_ASSERT(121, arg = TYPE_FUNC(object->type)->args);
+ if (IS_TYPEFUNC_NONSTATIC_METHOD(TYPE_FUNC(object->type)))
+ CError_ASSERT(125, arg = arg->next);
+
+ while (index > 0) {
+ CError_ASSERT(129, arg = arg->next);
+ index--;
+ }
+
+ *qual = arg->qual & Q_CV;
+ return arg->type;
+}
+
+static Boolean CExpr_HasNParams(Object *object, int count) {
+ FuncArg *arg;
+ int i;
+
+ CError_ASSERT(146, IS_TYPE_FUNC(object->type));
+ CError_ASSERT(147, arg = TYPE_FUNC(object->type)->args);
+ if (IS_TYPEFUNC_NONSTATIC_METHOD(TYPE_FUNC(object->type)))
+ arg = arg->next;
+
+ i = 0;
+ while (arg) {
+ arg = arg->next;
+ i++;
+ }
+
+ return i == count;
+}
+
+typedef enum TypeCompareMode {
+ TCM_0,
+ TCM_1,
+ TCM_2
+} TypeCompareMode;
+
+static Boolean CExpr_TypeCompare(Type *typeA, UInt32 qualA, Type *typeB, UInt32 qualB, TypeCompareMode mode) {
+ if (typeA->type != typeB->type)
+ return 0;
+
+ switch (mode) {
+ case TCM_0:
+ while (1) {
+ switch (typeA->type) {
+ case TYPEPOINTER:
+ typeA = TPTR_TARGET(typeA);
+ typeB = TPTR_TARGET(typeB);
+ if (typeA->type != typeB->type)
+ return 0;
+ continue;
+
+ case TYPEMEMBERPOINTER:
+ if (!is_typesame(TYPE_MEMBER_POINTER(typeA)->ty2, TYPE_MEMBER_POINTER(typeB)->ty2))
+ return 0;
+ typeA = TYPE_MEMBER_POINTER(typeA)->ty1;
+ typeB = TYPE_MEMBER_POINTER(typeB)->ty1;
+ if (typeA->type != typeB->type)
+ return 0;
+ continue;
+ }
+ break;
+ }
+ break;
+
+ case TCM_1:
+ switch (typeA->type) {
+ case TYPEPOINTER:
+ if ((qualA & Q_CV) != (qualB & Q_CV))
+ return 0;
+
+ typeA = TPTR_TARGET(typeA);
+ typeB = TPTR_TARGET(typeB);
+ break;
+
+ case TYPEMEMBERPOINTER:
+ if ((qualA & Q_CV) != (qualB & Q_CV))
+ return 0;
+
+ if (!is_typesame(TYPE_MEMBER_POINTER(typeA)->ty2, TYPE_MEMBER_POINTER(typeB)->ty2))
+ return 0;
+ typeA = TYPE_MEMBER_POINTER(typeA)->ty1;
+ typeB = TYPE_MEMBER_POINTER(typeB)->ty1;
+ break;
+ }
+ break;
+
+ case TCM_2:
+ if ((qualA & Q_CV) != (qualB & Q_CV))
+ return 0;
+ break;
+ }
+
+ return is_typesame(typeA, typeB);
+}
+
+static int CExpr_IsReferenceCompatible(Type *typeA, UInt32 qualA, Type *typeB, UInt32 qualB) {
+ if (CParser_IsSameOrMoreCVQualified(CParser_GetCVTypeQualifiers(typeA, qualA), CParser_GetCVTypeQualifiers(typeB, qualB))) {
+ if (CExpr_TypeCompare(typeA, qualA, typeB, qualB, TCM_1))
+ return 1;
+
+ if (IS_TYPE_CLASS(typeB) && IS_TYPE_CLASS(typeA)) {
+ short depth;
+ Boolean isambigbase;
+ if (CClass_GetBasePath(TYPE_CLASS(typeB), TYPE_CLASS(typeA), &depth, &isambigbase))
+ return 2;
+ }
+ }
+
+ return 0;
+}
+
+static Boolean CExpr_IsBaseOf(TypeClass *baseclass, TypeClass *superclass) {
+ ClassList *base;
+
+ for (base = superclass->bases; base; base = base->next) {
+ if (base->base == baseclass || CExpr_IsBaseOf(baseclass, base->base))
+ return 1;
+ }
+
+ return 0;
+}
+
+static Boolean CExpr_IsBetterClassConversion(TypeClass *a, TypeClass *b, TypeClass *c, TypeClass *d) {
+ if (a == c)
+ return CExpr_IsBaseOf(d, b);
+ if (b == d)
+ return CExpr_IsBaseOf(a, c);
+ return 0;
+}
+
+inline Boolean Inline_501D40(Type *a, Type *b) {
+ return (a == TYPE(&stbool)) && (IS_TYPE_POINTER_ONLY(b) || IS_TYPE_MEMBERPOINTER(b));
+}
+
+static Boolean CExpr_IsBetterStandardConv(StandardConv *a, StandardConv *b) {
+ Boolean flag10;
+ Boolean flag3;
+
+ flag10 = 1;
+ flag3 = 0;
+
+ if (b->x11) {
+ if (!a->x11)
+ flag3 = 1;
+ } else {
+ if (a->x11)
+ flag10 = 0;
+ }
+
+ if (b->x12) {
+ if (!a->x12)
+ flag3 = 1;
+ } else {
+ if (a->x12)
+ flag10 = 0;
+ }
+
+ if (b->x13) {
+ if (a->x13) {
+ if (Inline_501D40(b->type2, b->type1)) {
+ if (!Inline_501D40(a->type2, a->type1))
+ return 1;
+ } else {
+ if (Inline_501D40(a->type2, a->type1))
+ return 0;
+ }
+ } else {
+ flag3 = 1;
+ }
+ } else {
+ if (a->x13)
+ flag10 = 0;
+ }
+
+ if (flag10 && flag3)
+ return 1;
+
+ if (!a->x13) {
+ if (b->x13)
+ return 1;
+
+ if (a->x12) {
+ if (!b->x12)
+ return 0;
+ } else {
+ if (b->x12)
+ return 1;
+ }
+ } else {
+ if (!b->x13)
+ return 0;
+ }
+
+ if (
+ IS_TYPE_POINTER_ONLY(a->type1) &&
+ IS_TYPE_CLASS(TPTR_TARGET(a->type1)) &&
+ IS_TYPE_POINTER_ONLY(a->type2) &&
+ IS_TYPE_POINTER_ONLY(b->type1) &&
+ IS_TYPE_CLASS(TPTR_TARGET(b->type1)) &&
+ IS_TYPE_POINTER_ONLY(b->type2)
+ )
+ {
+ if (TPTR_TARGET(b->type2) == &stvoid) {
+ if (TPTR_TARGET(a->type2) == &stvoid) {
+ if (CExpr_IsBaseOf(TYPE_CLASS(TPTR_TARGET(a->type1)), TYPE_CLASS(TPTR_TARGET(b->type1))))
+ return 1;
+ } else {
+ if (TPTR_TARGET(a->type1) == TPTR_TARGET(b->type1) && IS_TYPE_CLASS(TPTR_TARGET(a->type2)))
+ return 1;
+ }
+ } else if (IS_TYPE_CLASS(TPTR_TARGET(a->type2)) && IS_TYPE_CLASS(TPTR_TARGET(b->type2))) {
+ if (CExpr_IsBetterClassConversion(
+ TYPE_CLASS(TPTR_TARGET(a->type1)),
+ TYPE_CLASS(TPTR_TARGET(a->type2)),
+ TYPE_CLASS(TPTR_TARGET(b->type1)),
+ TYPE_CLASS(TPTR_TARGET(b->type2))
+ ))
+ return 1;
+ }
+ }
+
+ if (
+ IS_TYPE_CLASS(a->type1) &&
+ IS_TYPE_CLASS(a->type2) &&
+ IS_TYPE_CLASS(b->type1) &&
+ IS_TYPE_CLASS(b->type2) &&
+ CExpr_IsBetterClassConversion(
+ TYPE_CLASS(a->type1),
+ TYPE_CLASS(a->type2),
+ TYPE_CLASS(b->type1),
+ TYPE_CLASS(b->type2)
+ )
+ )
+ return 1;
+
+ if (
+ IS_TYPE_MEMBERPOINTER(a->type1) &&
+ IS_TYPE_MEMBERPOINTER(a->type2) &&
+ IS_TYPE_MEMBERPOINTER(b->type1) &&
+ IS_TYPE_MEMBERPOINTER(b->type2) &&
+ IS_TYPE_CLASS(TYPE_MEMBER_POINTER(a->type1)->ty2) &&
+ IS_TYPE_CLASS(TYPE_MEMBER_POINTER(a->type2)->ty2) &&
+ IS_TYPE_CLASS(TYPE_MEMBER_POINTER(b->type1)->ty2) &&
+ IS_TYPE_CLASS(TYPE_MEMBER_POINTER(b->type2)->ty2) &&
+ CExpr_IsBetterClassConversion(
+ TYPE_CLASS(TYPE_MEMBER_POINTER(b->type1)->ty2),
+ TYPE_CLASS(TYPE_MEMBER_POINTER(b->type2)->ty2),
+ TYPE_CLASS(TYPE_MEMBER_POINTER(a->type1)->ty2),
+ TYPE_CLASS(TYPE_MEMBER_POINTER(a->type2)->ty2)
+ )
+ )
+ return 1;
+
+ if (
+ a->x14 &&
+ b->x14 &&
+ CExpr_TypeCompare(a->type2, a->qual2, b->type2, b->qual2, TCM_1) &&
+ CParser_IsMoreCVQualified(
+ CParser_GetTypeQualifiers(b->type2, b->qual2),
+ CParser_GetTypeQualifiers(a->type2, a->qual2)
+ )
+ )
+ return 1;
+
+ return 0;
+}
+
+static Boolean CExpr_IsBetterImplicitConv(ImplicitConv *a, ImplicitConv *b) {
+ if (a->type > b->type)
+ return 1;
+ if (a->type != b->type)
+ return 0;
+
+ if (a->type == ICT_3)
+ return CExpr_IsBetterStandardConv(&a->u.ic3.standardConv, &b->u.ic3.standardConv);
+
+ if (a->type == ICT_2 && a->u.ic2.x2 == b->u.ic2.x2 && CExpr_IsBetterStandardConv(&a->u.ic2.standardConv, &b->u.ic2.standardConv))
+ return 1;
+
+ return 0;
+}
+
+typedef enum SSCRMode {
+ SSCR_0,
+ SSCR_1,
+ SSCR_2
+} SSCRMode;
+
+static Boolean CExpr_SetupStandardConversionResult(ENode *expr, Type *type2, UInt32 qual2, SSCRMode mode, Boolean x14, Boolean refFlag, StandardConv *result) {
+ UInt32 cv1;
+ UInt32 cv2;
+
+ if (x14) {
+ if (!CParser_IsConst(type2, qual2)) {
+ if (!refFlag && !CExpr_IsLValue(expr))
+ return 0;
+ if (mode != SSCR_0 && !IS_TYPE_CLASS(type2))
+ return 0;
+ }
+
+ cv2 = CParser_GetTypeQualifiers(type2, qual2) & Q_CV;
+ cv1 = CParser_GetTypeQualifiers(expr->rtype, ENODE_QUALS(expr)) & Q_CV;
+ if (cv2 != cv1 && !CParser_IsMoreCVQualified(cv2, cv1))
+ return 0;
+ }
+
+ memclrw(result, sizeof(StandardConv));
+ result->type2 = type2;
+ result->qual2 = qual2;
+ result->type1 = expr->rtype;
+ result->qual1 = ENODE_QUALS(expr);
+ result->x14 = x14;
+
+ switch (mode) {
+ case SSCR_0:
+ break;
+ case SSCR_1:
+ result->x12 = 1;
+ break;
+ case SSCR_2:
+ result->x13 = 1;
+ break;
+ default:
+ CError_FATAL(581);
+ }
+
+ return 1;
+}
+
+typedef enum MysteryEnum {
+ ME_0,
+ ME_1,
+ ME_255 = 255
+} MysteryEnum;
+
+inline MysteryEnum Inline_501FF0(UInt32 qual1, UInt32 qual2) {
+ if ((qual1 & Q_CV) == (qual2 & Q_CV))
+ return ME_0;
+
+ if (((qual2 & Q_CONST) && !(qual1 & Q_CONST)) || ((qual2 & Q_VOLATILE) && !(qual1 & Q_VOLATILE)))
+ return ME_255;
+
+ return ME_1;
+}
+
+static Boolean CExpr_SetQualConversionResult(Type *type1, UInt32 qual1, Type *type2, UInt32 qual2, StandardConv *result) {
+ Boolean flag = 1;
+ UInt32 cv1;
+ UInt32 cv2;
+
+ while (1) {
+ cv1 = CParser_GetCVTypeQualifiers(type1, qual1);
+ cv2 = CParser_GetCVTypeQualifiers(type2, qual2);
+
+ switch (Inline_501FF0(cv1, cv2)) {
+ case ME_0:
+ break;
+
+ case ME_1:
+ result->x11 = 1;
+ if (!flag)
+ return 0;
+ break;
+
+ default:
+ return 0;
+ }
+
+ if (!(cv1 & Q_CONST))
+ flag = 0;
+
+ if (IS_TYPE_POINTER_ONLY(type1)) {
+ CError_ASSERT(635, IS_TYPE_POINTER_ONLY(type2));
+ type1 = TPTR_TARGET(type1);
+ type2 = TPTR_TARGET(type2);
+ } else {
+ if (!IS_TYPE_MEMBERPOINTER(type1))
+ return 1;
+
+ CError_ASSERT(642, IS_TYPE_MEMBERPOINTER(type2));
+ type1 = TYPE_MEMBER_POINTER(type1)->ty1;
+ type2 = TYPE_MEMBER_POINTER(type2)->ty1;
+ }
+ }
+}
+
+static Boolean CExpr_OverloadFuncMatch(NameSpaceObjectList *list, TemplArg *templargs, Type *type, ENode **outExpr) {
+ Object *object;
+ TemplFuncInstance *inst;
+ ENode *expr;
+ FuncArg *arg;
+ int i;
+ ObjectList *objlist;
+ Object *object26;
+ ObjectList *objlist25;
+ ObjectList *objlist24;
+ Boolean flag23;
+
+ if (!IS_TYPE_POINTER_ONLY(type) || !IS_TYPE_FUNC(type = TPTR_TARGET(type)))
+ return 0;
+
+ object26 = NULL;
+ objlist25 = NULL;
+ objlist24 = NULL;
+ flag23 = 0;
+
+ while (list) {
+ object = OBJECT(list->object);
+ if (object->otype == OT_OBJECT) {
+ if (IS_TEMPL_FUNC(object->type)) {
+ if (!flag23 && CTempl_CanDeduceFunc(object, TYPE_FUNC(type), templargs)) {
+ CError_ASSERT(685, inst = CTempl_DeduceFunc(object, TYPE_FUNC(type), templargs, NULL, 0));
+ if (is_typesame(inst->object->type, type)) {
+ objlist = lalloc(sizeof(ObjectList));
+ objlist->next = objlist24;
+ objlist->object = object;
+ objlist24 = objlist;
+
+ if (object26 && object26 != inst->object) {
+ objlist = lalloc(sizeof(ObjectList));
+ objlist->next = objlist25;
+ objlist->object = inst->object;
+ objlist25 = objlist;
+ } else {
+ object26 = inst->object;
+ }
+ }
+ }
+ } else if (is_typesame(object->type, type)) {
+ if (object26 && flag23) {
+ Object *checkA, *checkB;
+ checkA = object;
+ if (checkA->datatype == DALIAS)
+ checkA = checkA->u.alias.object;
+ checkB = object26;
+ if (checkB->datatype == DALIAS)
+ checkB = checkB->u.alias.object;
+ if (checkA != checkB) {
+ objlist = lalloc(sizeof(ObjectList));
+ objlist->next = objlist25;
+ objlist->object = object;
+ objlist25 = objlist;
+ }
+ } else {
+ objlist25 = NULL;
+ object26 = object;
+ }
+ flag23 = 1;
+ }
+ }
+ list = list->next;
+ }
+
+ if (object26) {
+ if (outExpr) {
+ if (objlist25) {
+ i = 0;
+ for (arg = TYPE_FUNC(object->type)->args; arg; arg = arg->next)
+ i++;
+
+ if (!flag23 && (object = CTempl_PartialOrdering(objlist24->object, objlist24->next, i))) {
+ CError_ASSERT(741, inst = CTempl_DeduceFunc(object, TYPE_FUNC(type), templargs, NULL, 0));
+ object26 = inst->object;
+ } else {
+ CError_OverloadedFunctionError(object26, objlist25);
+ }
+ }
+
+ expr = CExpr_MakeObjRefNode(object26, 1);
+ *outExpr = expr;
+ expr->rtype = CDecl_NewPointerType(object26->type);
+ expr->flags = object->qual & ENODE_FLAG_QUALS;
+ object26->flags |= OBJECT_FLAGS_UNUSED;
+ if (object26->datatype == DINLINEFUNC)
+ CError_Error(CErrorStr175);
+ }
+
+ return 1;
+ }
+
+ return 0;
+}
+
+static Boolean CExpr_StandardConversionMatch(ENode *expr, Type *type2, UInt32 qual2, Boolean x14, StandardConv *result) {
+ Type *type1;
+ UInt32 qual1;
+ Boolean refFlag;
+ Type *inner2;
+ Type *inner1;
+ SSCRMode mode;
+ NameSpaceObjectList list;
+
+ if (IS_TYPE_REFERENCE(type2)) {
+ type2 = TPTR_TARGET(type2);
+ if (IS_TYPE_POINTER_ONLY(type2))
+ expr = pointer_generation(expr);
+ refFlag = 1;
+ } else {
+ if (
+ (IS_TYPE_ARRAY(expr->rtype) && !IS_TYPE_ARRAY(type2)) ||
+ (IS_TYPE_FUNC(expr->rtype) && !IS_TYPE_FUNC(type2))
+ )
+ expr = pointer_generation(expr);
+ refFlag = 0;
+ }
+
+ type1 = expr->rtype;
+ qual1 = ENODE_QUALS(expr);
+
+ if (IS_TYPE_POINTER_ONLY(type2)) {
+ if (ENODE_IS(expr, EINTCONST) && CInt64_IsZero(&expr->data.intval)) {
+ if (IS_TYPE_INT(type1) || (!copts.cplusplus && IS_TYPE_ENUM(type1)))
+ return CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_2, x14, refFlag, result);
+ }
+
+ if (
+ IS_TYPE_INT(expr->rtype) &&
+ ENODE_IS_INDIRECT_TO(expr, EOBJREF) &&
+ (expr->data.monadic->data.objref->qual & Q_10000) &&
+ CInt64_IsZero(&expr->data.monadic->data.objref->u.data.u.intconst)
+ )
+ return CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_2, x14, refFlag, result);
+
+ if (ENODE_IS(expr, EOBJLIST))
+ return CExpr_OverloadFuncMatch(expr->data.objlist.list, expr->data.objlist.templargs, type2, NULL) &&
+ CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_0, refFlag, x14, result);
+
+ if (ENODE_IS(expr, EOBJREF) && IS_TEMPL_FUNC(expr->data.objref->type)) {
+ list.next = NULL;
+ list.object = OBJ_BASE(expr->data.objref);
+ return CExpr_OverloadFuncMatch(&list, NULL, type2, NULL) &&
+ CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_0, refFlag, x14, result);
+ }
+
+ if (IS_TYPE_POINTER_ONLY(type1)) {
+ if (
+ ENODE_IS(expr, ESTRINGCONST) &&
+ TPTR_TARGET(type2) == TPTR_TARGET(type1) &&
+ !(qual2 & Q_CONST) &&
+ (
+ TPTR_TARGET(type2) == TYPE(&stchar) ||
+ TPTR_TARGET(type2) == TYPE(&stunsignedchar) ||
+ TPTR_TARGET(type2) == CParser_GetWCharType()
+ )
+ )
+ {
+ if (
+ CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_0, refFlag, x14, result) &&
+ CExpr_SetQualConversionResult(TPTR_TARGET(type2), qual2, TPTR_TARGET(type1), qual1 & ~Q_CONST, result)
+ )
+ {
+ result->x11 = 1;
+ return 1;
+ } else {
+ return 0;
+ }
+ }
+
+ if (copts.objective_c && CObjC_IsCompatibleType(expr->rtype, type2))
+ return CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_2, x14, refFlag, result);
+
+ if (IS_TYPE_VOID(TPTR_TARGET(type2)) || (!copts.cplusplus && IS_TYPE_VOID(TPTR_TARGET(type1)))) {
+ if (CExpr_SetupStandardConversionResult(expr, type2, qual2, IS_TYPE_VOID(TPTR_TARGET(type1)) ? SSCR_0 : SSCR_2, refFlag, x14, result)) {
+ switch (Inline_501FF0(qual2, CParser_GetCVTypeQualifiers(TPTR_TARGET(type1), qual1))) {
+ case ME_1:
+ result->x11 = 1;
+ case ME_0:
+ return 1;
+ default:
+ return 0;
+ }
+ } else {
+ return 0;
+ }
+ }
+
+ inner2 = TPTR_TARGET(type2);
+ inner1 = TPTR_TARGET(type1);
+ while (1) {
+ if (inner2->type != inner1->type)
+ break;
+
+ switch (inner2->type) {
+ case TYPEPOINTER:
+ inner2 = TPTR_TARGET(inner2);
+ inner1 = TPTR_TARGET(inner1);
+ continue;
+ case TYPEMEMBERPOINTER:
+ if (!is_typesame(TYPE_MEMBER_POINTER(inner2)->ty2, TYPE_MEMBER_POINTER(inner1)->ty2))
+ break;
+
+ inner2 = TYPE_MEMBER_POINTER(inner2)->ty1;
+ inner1 = TYPE_MEMBER_POINTER(inner1)->ty1;
+ if (!IS_TYPE_POINTER_ONLY(inner2) && !IS_TYPE_MEMBERPOINTER(inner2)) {
+ if (!is_memberpointerequal(inner2, inner1))
+ break;
+
+ if (CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_0, refFlag, x14, result))
+ return CExpr_SetQualConversionResult(TPTR_TARGET(type2), qual2, TPTR_TARGET(type1), qual1, result);
+ else
+ return 0;
+ }
+ continue;
+ default:
+ if (!is_typesame(inner2, inner1))
+ break;
+
+ if (CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_0, refFlag, x14, result))
+ return CExpr_SetQualConversionResult(TPTR_TARGET(type2), qual2, TPTR_TARGET(type1), qual1, result);
+ else
+ return 0;
+ }
+
+ break;
+ }
+
+ if (IS_TYPE_CLASS(TPTR_TARGET(type2)) && IS_TYPE_CLASS(TPTR_TARGET(type1))) {
+ short depth;
+ Boolean isambigbase;
+ if (CClass_GetBasePath(TYPE_CLASS(TPTR_TARGET(type1)), TYPE_CLASS(TPTR_TARGET(type2)), &depth, &isambigbase)) {
+ if (CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_2, refFlag, x14, result))
+ return CExpr_SetQualConversionResult(TPTR_TARGET(type2), qual2, TPTR_TARGET(type1), qual1, result);
+ else
+ return 0;
+ }
+ }
+ }
+
+ if (copts.mpwc_relax && !copts.cplusplus && IS_TYPE_POINTER_ONLY(type1)) {
+ if (CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_2, refFlag, x14, result))
+ return 1;
+ }
+
+ return 0;
+ }
+
+ if (is_typesame(type2, type1))
+ return CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_0, refFlag, x14, result);
+
+ if (type2 == TYPE(&stbool)) {
+ switch (type1->type) {
+ case TYPEINT:
+ case TYPEFLOAT:
+ case TYPEENUM:
+ case TYPEMEMBERPOINTER:
+ case TYPEPOINTER:
+ return CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_2, refFlag, x14, result);
+ default:
+ return 0;
+ }
+ }
+
+ if (IS_TYPE_MEMBERPOINTER(type2)) {
+ if (ENODE_IS(expr, EINTCONST) && CInt64_IsZero(&expr->data.intval)) {
+ if (IS_TYPE_INT(type1) || (!copts.cplusplus && IS_TYPE_ENUM(type1)))
+ return CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_2, refFlag, x14, result);
+ }
+
+ if (ENODE_IS(expr, EMEMBER)) {
+ expr = getpointertomemberfunc(expr, type2, 0);
+ type1 = expr->rtype;
+ }
+
+ if (IS_TYPE_MEMBERPOINTER(type1)) {
+ short depth;
+ Boolean isambigbase;
+
+ CError_ASSERT(996, IS_TYPE_CLASS(TYPE_MEMBER_POINTER(type2)->ty2) && IS_TYPE_CLASS(TYPE_MEMBER_POINTER(type1)->ty2));
+ if (!is_memberpointerequal(TYPE_MEMBER_POINTER(type2)->ty1, TYPE_MEMBER_POINTER(type1)->ty1))
+ return 0;
+
+ if (
+ TYPE_MEMBER_POINTER(type2)->ty2 == TYPE_MEMBER_POINTER(type1)->ty2 ||
+ CClass_GetBasePath(TYPE_CLASS(TYPE_MEMBER_POINTER(type2)->ty2), TYPE_CLASS(TYPE_MEMBER_POINTER(type1)->ty2), &depth, &isambigbase)
+ )
+ {
+ if (CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_2, refFlag, x14, result))
+ return CExpr_SetQualConversionResult(TYPE_MEMBER_POINTER(type2)->ty1, qual2, TYPE_MEMBER_POINTER(type1)->ty1, qual1, result);
+ else
+ return 0;
+ }
+ }
+
+ return 0;
+ }
+
+ mode = SSCR_2;
+ switch (type1->type) {
+ case TYPEINT:
+ switch (type2->type) {
+ case TYPEINT:
+ if (TYPE_INTEGRAL(type1)->integral < IT_INT) {
+ if (type2 == TYPE(&stsignedint)) {
+ if (type1->size < type2->size || !is_unsigned(type1))
+ mode = SSCR_1;
+ } else if (type2 == TYPE(&stunsignedint)) {
+ if (type2->size == type1->size && is_unsigned(type1))
+ mode = SSCR_1;
+ }
+ }
+ break;
+ case TYPEFLOAT:
+ break;
+ case TYPEENUM:
+ if (copts.cplusplus)
+ return 0;
+ break;
+ default:
+ return 0;
+ }
+ break;
+
+ case TYPEFLOAT:
+ switch (type2->type) {
+ case TYPEINT:
+ break;
+ case TYPEFLOAT:
+ if (type2 == TYPE(&stdouble)) {
+ if (type1 == TYPE(&stfloat) || type1 == TYPE(&stshortdouble))
+ mode = SSCR_1;
+ }
+ break;
+ case TYPEENUM:
+ if (copts.cplusplus)
+ return 0;
+ break;
+ default:
+ return 0;
+ }
+ break;
+
+ case TYPEENUM:
+ switch (type2->type) {
+ case TYPEINT:
+ if (TYPE_INTEGRAL(TYPE_ENUM(expr->rtype)->enumtype)->integral < IT_INT) {
+ if (type1->size == type2->size && is_unsigned(TYPE_ENUM(type1)->enumtype)) {
+ if (type2 == TYPE(&stunsignedint))
+ mode = SSCR_1;
+ } else {
+ if (type2 == TYPE(&stsignedint))
+ mode = SSCR_1;
+ }
+ } else {
+ if (TYPE_ENUM(type1)->enumtype == type2)
+ mode = SSCR_1;
+ }
+ break;
+ case TYPEFLOAT:
+ break;
+ case TYPEENUM:
+ if (copts.cplusplus)
+ return 0;
+ break;
+ default:
+ return 0;
+ }
+ break;
+
+ case TYPECLASS: {
+ short depth;
+ Boolean isambigbase;
+
+ if (!IS_TYPE_CLASS(type1) || !CClass_GetBasePath(TYPE_CLASS(type1), TYPE_CLASS(type2), &depth, &isambigbase))
+ return 0;
+ break;
+ }
+
+ default:
+ return 0;
+ }
+
+ return CExpr_SetupStandardConversionResult(expr, type2, qual2, mode, refFlag, x14, result);
+}
+
+static ENode *CExpr_UserConversion(ENode *expr, Type *type2, UInt32 qual2, ImplicitConv *result, Boolean flag1, Boolean isExplicit, Boolean flag3) {
+ Object *object28;
+ Object *object27;
+ Object *object26;
+ ObjectList *objlist25;
+ ObjectList *objlist24;
+ ObjectList *objlist;
+ TypeFunc *tfunc23;
+ Type *tmptype23;
+ NameSpaceObjectList *list22;
+ Boolean flag22;
+ Boolean flag21;
+ FuncArg *arg21;
+ Boolean flag20;
+ ENode *newExpr;
+ ENode *funcref;
+ ENode *tmpExpr;
+ ENodeList *arglist;
+ UInt32 q1;
+ UInt32 q2;
+ StandardConv sc3;
+ StandardConv sc2;
+ StandardConv sc1;
+ ConversionIterator convIter;
+ ENodeList myarglist;
+ ObjectList myobjlist;
+ BClassList path;
+
+ object28 = NULL;
+ object27 = NULL;
+ objlist25 = NULL;
+ objlist24 = NULL;
+
+ if (type2->size == 0)
+ CDecl_CompleteType(type2);
+ if (expr->rtype->size == 0)
+ CDecl_CompleteType(expr->rtype);
+
+ if (IS_TYPE_CLASS(expr->rtype)) {
+ CExpr_ConversionIteratorInit(&convIter, TYPE_CLASS(expr->rtype));
+ flag22 = 1;
+ while ((object26 = CExpr_ConversionIteratorNext(&convIter))) {
+ tfunc23 = TYPE_FUNC(object26->type);
+ if (tfunc23->flags & FUNC_FLAGS_100000) {
+ object26 = CTempl_DeduceFromConversion(object26, type2, qual2);
+ if (!object26)
+ continue;
+ tfunc23 = TYPE_FUNC(object26->type);
+ }
+
+ if (flag3) {
+ if (
+ !IS_TYPE_REFERENCE(tfunc23->functype) ||
+ !CExpr_IsReferenceCompatible(type2, qual2, TPTR_TARGET(tfunc23->functype), tfunc23->qual)
+ )
+ continue;
+ }
+
+ CError_ASSERT(1230, tfunc23->args && IS_TYPE_POINTER_ONLY(tfunc23->args->type));
+
+ q1 = ENODE_QUALS(expr);
+ q2 = tfunc23->args->qual;
+ if ((q1 & Q_CV) != (q2 & Q_CV)) {
+ if (!flag22)
+ continue;
+ if ((q1 & Q_CONST) && !(q2 & Q_CONST))
+ continue;
+ if ((q1 & Q_VOLATILE) && !(q2 & Q_VOLATILE))
+ continue;
+ flag21 = 1;
+ } else {
+ flag21 = 0;
+ }
+
+ newExpr = CExpr_NewENode(ETEMP);
+ newExpr->rtype = tfunc23->functype;
+ newExpr->flags = tfunc23->qual & ENODE_FLAG_QUALS;
+ flag20 = 0;
+
+ if (IS_TYPE_REFERENCE(newExpr->rtype)) {
+ newExpr->rtype = TPTR_TARGET(newExpr->rtype);
+ if (!CParser_IsConst(newExpr->rtype, tfunc23->qual)) {
+ newExpr = makemonadicnode(newExpr, EINDIRECT);
+ newExpr->data.monadic->rtype = TYPE(&void_ptr);
+ newExpr = makemonadicnode(newExpr, EINDIRECT);
+ newExpr->data.monadic->rtype = TYPE(&void_ptr);
+ flag20 = 1;
+ }
+ }
+
+ if (CExpr_StandardConversionMatch(newExpr, type2, qual2, 0, &sc1)) {
+ if (flag22 && !flag21) {
+ object28 = NULL;
+ objlist25 = NULL;
+ flag22 = 0;
+ }
+
+ if (object28 && object28 != object26) {
+ if (CExpr_IsBetterStandardConv(&sc3, &sc1))
+ continue;
+
+ if (!CExpr_IsBetterStandardConv(&sc1, &sc3)) {
+ objlist = lalloc(sizeof(ObjectList));
+ objlist->next = objlist25;
+ objlist->object = object28;
+ objlist25 = objlist;
+ } else {
+ objlist25 = NULL;
+ }
+ }
+
+ object28 = object26;
+ sc3 = sc1;
+ sc3.x15 = flag20;
+ }
+ }
+ }
+
+ if (!flag3 && IS_TYPE_CLASS(type2) && (list22 = CClass_Constructor(TYPE_CLASS(type2)))) {
+ for (; list22; list22 = list22->next) {
+ object26 = OBJECT(list22->object);
+ if (
+ object26->otype == OT_OBJECT &&
+ IS_TYPE_FUNC(tfunc23 = TYPE_FUNC(object26->type)) &&
+ (isExplicit || !(object26->qual & Q_EXPLICIT))
+ )
+ {
+ if (tfunc23->flags & FUNC_FLAGS_100000) {
+ myarglist.next = NULL;
+ myarglist.node = expr;
+ object26 = CTempl_DeduceFromFunctionCall(object26, NULL, &myarglist);
+ if (!object26)
+ continue;
+ tfunc23 = TYPE_FUNC(object26->type);
+ }
+
+ if (!(arg21 = tfunc23->args))
+ continue;
+ if (!(arg21 = arg21->next))
+ continue;
+ if ((TYPE_CLASS(type2)->flags & CLASS_FLAGS_20) && !(arg21 = arg21->next))
+ continue;
+ if (arg21 == &elipsis)
+ continue;
+ if (arg21->next && !arg21->next->dexpr && arg21->next != &elipsis)
+ continue;
+
+ tmptype23 = arg21->type;
+ if (IS_TYPE_REFERENCE(tmptype23)) {
+ tmptype23 = TPTR_TARGET(tmptype23);
+ if (!CParser_IsConst(tmptype23, arg21->qual) && !CExpr_IsLValue(expr))
+ continue;
+ }
+
+ if (CExpr_StandardConversionMatch(expr, tmptype23, arg21->qual, 0, &sc1)) {
+ if (object27) {
+ if (!object26->u.func.inst && !object27->u.func.inst)
+ continue;
+ if (CExpr_IsBetterStandardConv(&sc2, &sc1))
+ continue;
+
+ if (!CExpr_IsBetterStandardConv(&sc1, &sc2)) {
+ if (!object26->u.func.inst && object27->u.func.inst) {
+ objlist24 = NULL;
+ } else {
+ objlist = lalloc(sizeof(ObjectList));
+ objlist->next = objlist25;
+ objlist->object = object28;
+ objlist25 = objlist;
+ }
+ } else {
+ objlist25 = NULL;
+ }
+ }
+
+ object27 = object26;
+ sc2 = sc1;
+ }
+ }
+ }
+ }
+
+ if (object28 && object27) {
+ if (!CExpr_IsBetterStandardConv(&sc2, &sc3)) {
+ if (!CExpr_IsBetterStandardConv(&sc3, &sc2)) {
+ if (result) {
+ result->type = ICT_2;
+ result->u.ic2.x2 = object28;
+ result->u.ic2.standardConv = sc3;
+ }
+ if (flag1) {
+ myobjlist.next = NULL;
+ myobjlist.object = object27;
+ CError_OverloadedFunctionError(object28, &myobjlist);
+ }
+ } else {
+ object27 = NULL;
+ }
+ } else {
+ object28 = NULL;
+ }
+ }
+
+ if (object28) {
+ if (result) {
+ result->type = ICT_2;
+ result->u.ic2.x2 = object28;
+ result->u.ic2.standardConv = sc3;
+ }
+ if (!flag1)
+ return expr;
+ if (objlist25)
+ CError_OverloadedFunctionError(object28, objlist25);
+ tfunc23 = TYPE_FUNC(object28->type);
+ CError_ASSERT(1416, IS_TYPEFUNC_METHOD(tfunc23));
+
+ funcref = create_objectrefnode(object28);
+ object28->flags |= OBJECT_FLAGS_UNUSED;
+
+ arglist = lalloc(sizeof(ENodeList));
+ arglist->next = NULL;
+
+ expr = getnodeaddress(expr, 0);
+ arglist->node = CExpr_AssignmentPromotion(
+ expr,
+ CDecl_NewPointerType(TYPE(TYPE_METHOD(tfunc23)->theclass)),
+ expr->flags,
+ 0);
+
+ newExpr = lalloc(sizeof(ENode));
+ newExpr->type = EFUNCCALL;
+ newExpr->cost = 4;
+ newExpr->rtype = tfunc23->functype;
+ newExpr->flags = tfunc23->qual & ENODE_FLAG_QUALS;
+ newExpr->data.funccall.funcref = funcref;
+ newExpr->data.funccall.args = arglist;
+ newExpr->data.funccall.functype = TYPE_FUNC(object28->type);
+ newExpr = CExpr_AdjustFunctionCall(newExpr);
+ newExpr = checkreference(newExpr);
+
+ if (newExpr->rtype != type2) {
+ if (flag3) {
+ tmpExpr = CExpr_DerivedToBase(newExpr, type2, qual2, 1, 0, 1);
+ if (tmpExpr)
+ return tmpExpr;
+ }
+ newExpr = CExpr_Convert(newExpr, type2, qual2, 0, 1);
+ }
+ return newExpr;
+ }
+
+ if (object27) {
+ if (result) {
+ result->type = ICT_2;
+ result->u.ic2.x2 = object27;
+ result->u.ic2.standardConv = sc2;
+ }
+ if (!flag1)
+ return expr;
+ if (objlist24)
+ CError_OverloadedFunctionError(object27, objlist24);
+
+ arglist = lalloc(sizeof(ENodeList));
+ arglist->next = NULL;
+ arglist->node = expr;
+
+ if (TYPE_CLASS(type2)->flags & CLASS_FLAGS_20) {
+ arglist->next = lalloc(sizeof(ENodeList));
+ arglist->next->node = expr;
+ arglist->next->next = NULL;
+ arglist->node = intconstnode(TYPE(&stsignedshort), 1);
+ }
+
+ path.next = NULL;
+ path.type = type2;
+
+ tmpExpr = makemonadicnode(create_temp_node(type2), EINDIRECT);
+ tmpExpr->rtype = type2;
+
+ newExpr = CExpr_GenericFuncCall(
+ &path, tmpExpr, 0, object27, NULL, NULL, arglist, 0, 0, 1
+ );
+
+ if (ENODE_IS2(newExpr, EFUNCCALL, EFUNCCALLP)) {
+ newExpr->rtype = CDecl_NewPointerType(type2);
+ newExpr = makemonadicnode(newExpr, EINDIRECT);
+ newExpr->rtype = type2;
+ }
+
+ return newExpr;
+ }
+
+ return NULL;
+}
+
+static Boolean CExpr_UserConversionMatch(ENode *expr, Type *type2, UInt32 qual2, ImplicitConv *result) {
+ Boolean flag;
+
+ if (IS_TYPE_REFERENCE(type2)) {
+ type2 = TPTR_TARGET(type2);
+ flag = !CParser_IsConst(type2, qual2);
+ } else {
+ expr = pointer_generation(expr);
+ flag = 0;
+ }
+
+ if (CExpr_UserConversion(expr, type2, qual2, result, 0, 0, flag))
+ return 1;
+
+ return 0;
+}
+
+static Boolean CExpr_ImplicitConversionMatch(ENode *expr, Type *type2, UInt32 qual2, ImplicitConv *result) {
+ if (CExpr_StandardConversionMatch(expr, type2, qual2, 0, &result->u.ic3.standardConv)) {
+ result->type = ICT_3;
+ return 1;
+ }
+
+ if (IS_TYPE_CLASS(expr->rtype) || IS_TYPE_CLASS(type2) || (IS_TYPE_REFERENCE(type2) && IS_TYPE_CLASS(TPTR_TARGET(type2)))) {
+ if (CExpr_UserConversionMatch(expr, type2, qual2, result)) {
+ result->type = ICT_2;
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+Boolean CExpr_CanImplicitlyConvert(ENode *expr, Type *type2, UInt32 qual2) {
+ ImplicitConv result;
+ return CExpr_ImplicitConversionMatch(expr, type2, qual2, &result);
+}
+
+static ENode *CExpr_DerivedToBase(ENode *expr, Type *type2, UInt32 qual2, Boolean flag1, Boolean nullcheckflag, Boolean pathcheckflag) {
+ BClassList *path;
+ short depth;
+ Boolean isambigbase;
+
+ if (
+ IS_TYPE_CLASS(type2) &&
+ IS_TYPE_CLASS(expr->rtype) &&
+ (path = CClass_GetBasePath(TYPE_CLASS(expr->rtype), TYPE_CLASS(type2), &depth, &isambigbase))
+ )
+ {
+ if (isambigbase)
+ CError_Error(CErrorStr188);
+ if (flag1)
+ CClass_CheckPathAccess(path, NULL, ACCESSPUBLIC);
+
+ if (pathcheckflag) {
+ expr = getnodeaddress(expr, 0);
+ expr = makemonadicnode(CExpr_ClassPointerCast(path, expr, nullcheckflag), EINDIRECT);
+ expr->rtype = type2;
+ expr->flags = qual2 & ENODE_FLAG_QUALS;
+ }
+
+ return expr;
+ }
+ else {
+ return NULL;
+ }
+}
+
+static ENode *CExpr_ClassReferenceConversion(ENode *expr, Type *type2, UInt32 qual2, Boolean pathcheckflag) {
+ int refcompat;
+
+ if (CExpr_IsLValue(expr) && IS_TYPE_CLASS(type2) && IS_TYPE_CLASS(expr->rtype)) {
+ refcompat = CExpr_IsReferenceCompatible(type2, 0, expr->rtype, 0);
+ if (refcompat > 0) {
+ if (refcompat == 2) {
+ CError_ASSERT(1668, IS_TYPE_CLASS(type2) && IS_TYPE_CLASS(expr->rtype));
+ expr = CExpr_DerivedToBase(expr, type2, qual2, pathcheckflag, 0, 1);
+ }
+ expr->flags = qual2 & ENODE_FLAG_QUALS;
+ return expr;
+ }
+
+ refcompat = CExpr_IsReferenceCompatible(expr->rtype, 0, type2, 0);
+ if (refcompat > 0) {
+ expr = CClass_ClassPointerCast(
+ getnodeaddress(expr, 0),
+ TYPE_CLASS(expr->rtype), TYPE_CLASS(type2),
+ 1, 1, pathcheckflag
+ );
+ CError_ASSERT(1680, IS_TYPE_POINTER_ONLY(expr->rtype));
+ expr = makemonadicnode(expr, EINDIRECT);
+ expr->rtype = type2;
+ expr->flags = qual2 & ENODE_FLAG_QUALS;
+ return expr;
+ }
+ }
+
+ if (IS_TYPE_CLASS(expr->rtype)) {
+ if ((expr = CExpr_UserConversion(expr, type2, qual2, NULL, 1, 0, 1)))
+ return expr;
+ }
+
+ return NULL;
+}
+
+static ENode *CExpr_BindToReference(ENode *expr, Type *type2, UInt32 qual2) {
+ UInt32 cv;
+ int refcompat;
+ ENode *tmp;
+
+ cv = CParser_GetCVTypeQualifiers(type2, qual2);
+
+ if (CExpr_IsLValue(expr)) {
+ refcompat = CExpr_IsReferenceCompatible(type2, qual2, expr->rtype, ENODE_QUALS(expr));
+ if (refcompat > 0) {
+ if (refcompat == 2) {
+ CError_ASSERT(1718, IS_TYPE_CLASS(type2) && IS_TYPE_CLASS(expr->rtype));
+ expr = CExpr_DerivedToBase(expr, type2, qual2, 1, 0, 1);
+ }
+ return getnodeaddress(expr, 0);
+ }
+ } else if (IS_TYPE_CLASS(type2) && IS_TYPE_CLASS(expr->rtype)) {
+ refcompat = CExpr_IsReferenceCompatible(type2, qual2, expr->rtype, ENODE_QUALS(expr));
+ if (refcompat > 0) {
+ if (refcompat == 2)
+ expr = CExpr_DerivedToBase(expr, type2, qual2, 1, 0, 1);
+ return getnodeaddress(expr, 0);
+ }
+ }
+
+ if (IS_TYPE_CLASS(expr->rtype)) {
+ if ((tmp = CExpr_UserConversion(expr, type2, qual2, NULL, 1, 0, 1)))
+ return getnodeaddress(tmp, 0);
+ }
+
+ if (!(cv & Q_CONST))
+ CError_Error(CErrorStr228);
+ if (cv & Q_VOLATILE)
+ CError_Error(CErrorStr259);
+
+ if (expr->rtype != type2)
+ expr = CExpr_Convert(expr, type2, qual2, 0, 1);
+
+ if (!CExpr_IsLValue(expr)) {
+ expr = CExpr_LValue(expr, 0, 0);
+ if (!ENODE_IS(expr, EINDIRECT))
+ expr = get_address_of_temp_copy(expr, 1);
+ else
+ expr = getnodeaddress(expr, 0);
+ } else {
+ expr = getnodeaddress(expr, 0);
+ }
+
+ return expr;
+}
+
+ENode *CExpr_Convert(ENode *expr, Type *type, UInt32 qual, Boolean isExplicit, Boolean flag2) {
+ UInt32 cv;
+ ENode *refExpr;
+ ENode *newExpr;
+ Type *typeCopy;
+ NameSpaceObjectList myList;
+
+ cv = qual & Q_CV;
+
+ if (copts.cpp_extensions && is_typesame(expr->rtype, type) && !ENODE_IS(expr, EOBJLIST)) {
+ expr = CExpr_RewriteConst(expr);
+ expr->rtype = type;
+ expr->flags &= ~ENODE_FLAG_QUALS;
+ expr->flags |= cv;
+ return expr;
+ }
+
+ if (type == TYPE(&stvoid)) {
+ expr = makemonadicnode(expr, ETYPCON);
+ expr->rtype = type;
+ expr->flags = cv;
+ return expr;
+ }
+
+ if (IS_TYPE_REFERENCE(type)) {
+ if (isExplicit) {
+ refExpr = CExpr_ClassReferenceConversion(expr, TPTR_TARGET(type), qual, flag2);
+ if (refExpr)
+ return refExpr;
+
+ expr = getnodeaddress(expr, 0);
+ typeCopy = galloc(sizeof(TypePointer));
+ *TYPE_POINTER(typeCopy) = *TYPE_POINTER(type);
+ TPTR_QUAL(typeCopy) &= ~Q_REFERENCE;
+ expr = CExpr_Convert(expr, typeCopy, qual, 0, flag2);
+ expr = makemonadicnode(expr, EINDIRECT);
+ expr->rtype = TPTR_TARGET(type);
+ expr->flags = cv;
+ return expr;
+ } else {
+ return CExpr_BindToReference(expr, TPTR_TARGET(type), qual);
+ }
+ }
+
+ if (
+ (IS_TYPE_ARRAY(expr->rtype) && !IS_TYPE_ARRAY(type)) ||
+ (IS_TYPE_FUNC(expr->rtype) && !IS_TYPE_FUNC(type))
+ )
+ {
+ expr = pointer_generation(expr);
+ } else {
+ expr = CExpr_RewriteConst(expr);
+ }
+
+ if (ENODE_IS(expr, EOBJLIST)) {
+ if (CExpr_OverloadFuncMatch(expr->data.objlist.list, expr->data.objlist.templargs, type, &refExpr))
+ return refExpr;
+ } else if (ENODE_IS(expr, EOBJREF) && IS_TEMPL_FUNC(expr->data.objref->type)) {
+ myList.next = NULL;
+ myList.object = OBJ_BASE(expr->data.objref);
+ if (CExpr_OverloadFuncMatch(&myList, NULL, type, &refExpr))
+ return refExpr;
+ } else if (IS_TYPE_CLASS(expr->rtype) || IS_TYPE_CLASS(type)) {
+ if (expr->rtype->size == 0)
+ CDecl_CompleteType(expr->rtype);
+
+ if (IS_TYPE_CLASS(type)) {
+ CanAllocObject(type);
+ if (!CClass_CopyConstructor(TYPE_CLASS(type)) || CClass_IsTrivialCopyClass(TYPE_CLASS(type))) {
+ if (expr->rtype == type)
+ return expr;
+
+ refExpr = CExpr_DerivedToBase(expr, type, qual, flag2, 0, 1);
+ if (refExpr)
+ return refExpr;
+ }
+ }
+
+ refExpr = CExpr_UserConversion(expr, type, qual, NULL, 1, isExplicit, 0);
+ if (refExpr) {
+ refExpr->flags = cv;
+ return refExpr;
+ }
+ } else if (!isExplicit && is_typesame(expr->rtype, type)) {
+ if (ENODE_IS(expr, EINDIRECT) && ENODE_QUALS(expr) != cv)
+ expr = makemonadicnode(expr, ETYPCON);
+ expr->rtype = type;
+ expr->flags = cv;
+ return expr;
+ } else {
+ if (
+ copts.warn_implicitconv &&
+ !isExplicit &&
+ IS_TYPE_INT_OR_FLOAT(type) &&
+ IS_TYPE_INT_OR_FLOAT(expr->rtype)
+ )
+ CExpr_CheckArithmConversion(expr, type);
+
+ switch (type->type) {
+ case TYPEINT:
+ if (type == TYPE(&stbool)) {
+ switch (expr->rtype->type) {
+ case TYPEINT:
+ case TYPEFLOAT:
+ case TYPEENUM:
+ case TYPEMEMBERPOINTER:
+ case TYPEPOINTER:
+ return CExpr_ConvertToBool(expr, isExplicit);
+ }
+ } else {
+ switch (expr->rtype->type) {
+ case TYPEENUM:
+ expr->rtype = TYPE_ENUM(expr->rtype)->enumtype;
+ case TYPEINT:
+ case TYPEFLOAT:
+ do_int_float_conversion:
+ if (
+ ENODE_IS(expr, ETYPCON) &&
+ expr->rtype->type == type->type &&
+ expr->rtype->size == type->size &&
+ is_unsigned(expr->rtype) == is_unsigned(type) &&
+ ENODE_QUALS(expr) == qual
+ )
+ {
+ expr->rtype = type;
+ expr->flags |= ENODE_FLAG_80;
+ return expr;
+ } else {
+ refExpr = promote(expr, type);
+ refExpr->flags = cv;
+ return refExpr;
+ }
+ break;
+ case TYPEPOINTER:
+ if (expr->rtype->size > type->size && copts.warn_ptr_int_conv)
+ CError_Warning(CErrorStr382);
+ if (ENODE_IS(expr, ETYPCON)) {
+ ENode *inner = expr->data.monadic;
+ if (ENODE_IS(inner, EINTCONST)) {
+ inner->rtype = type;
+ inner->flags = cv;
+ inner->data.intval = CExpr_IntConstConvert(type, TYPE(&stunsignedlong), inner->data.intval);
+ return inner;
+ }
+ }
+ if (type->size != 4) {
+ expr = makemonadicnode(expr, ETYPCON);
+ expr->rtype = TYPE(&stunsignedlong);
+ }
+ expr = makemonadicnode(expr, ETYPCON);
+ expr->rtype = type;
+ expr->flags = cv;
+ return expr;
+ }
+ }
+ break;
+
+ case TYPEFLOAT:
+ switch (expr->rtype->type) {
+ case TYPEENUM:
+ expr->rtype = TYPE_ENUM(expr->rtype)->enumtype;
+ case TYPEINT:
+ case TYPEFLOAT:
+ goto do_int_float_conversion;
+ }
+ break;
+
+ case TYPEENUM:
+ expr = CExpr_Convert(expr, TYPE_ENUM(type)->enumtype, qual, isExplicit, flag2);
+ if (!ENODE_IS(expr, EINTCONST))
+ expr = makemonadicnode(expr, ETYPCON);
+ expr->rtype = type;
+ expr->flags = cv;
+ return expr;
+
+ case TYPEPOINTER:
+ switch (expr->rtype->type) {
+ case TYPEENUM:
+ expr->rtype = TYPE_ENUM(expr->rtype)->enumtype;
+ case TYPEINT:
+ if (expr->rtype->size != 4) {
+ if (!ENODE_IS(expr, EINTCONST))
+ expr = makemonadicnode(expr, ETYPCON);
+ expr->rtype = TYPE(&stunsignedlong);
+ }
+ expr = makemonadicnode(expr, ETYPCON);
+ expr->rtype = type;
+ expr->flags = cv;
+ return expr;
+
+ case TYPEPOINTER:
+ if (IS_TYPE_CLASS(TPTR_TARGET(expr->rtype)) && IS_TYPE_CLASS(TPTR_TARGET(type)))
+ expr = CExpr_SafeClassPointerCast(expr, TYPE_CLASS(TPTR_TARGET(expr->rtype)), TYPE_CLASS(TPTR_TARGET(type)), 1, flag2);
+ if (!ENODE_IS(expr, ETYPCON))
+ expr = makemonadicnode(expr, ETYPCON);
+ expr->rtype = type;
+ expr->flags = cv;
+ return expr;
+ }
+ break;
+
+ case TYPEMEMBERPOINTER:
+ if (!IS_TYPE_MEMBERPOINTER(expr->rtype))
+ expr = CExpr_MemberPointerConversion(expr, TYPE_MEMBER_POINTER(type), 1);
+
+ if (IS_TYPE_MEMBERPOINTER(expr->rtype)) {
+ expr = PointerToMemberCast(expr, TYPE_MEMBER_POINTER(expr->rtype), TYPE_MEMBER_POINTER(type), flag2);
+ expr->flags = cv;
+ return expr;
+ }
+ break;
+ }
+ }
+
+ if (isExplicit) {
+ if ((newExpr = CodeGen_HandleTypeCast(expr, type, qual)))
+ return newExpr;
+ }
+
+ CError_Error(
+ isExplicit ? CErrorStr247 : CErrorStr209,
+ expr->rtype, ENODE_QUALS(expr),
+ type, qual);
+ return nullnode();
+}
+
+ENode *CExpr_AssignmentPromotion(ENode *expr, Type *type2, UInt32 qual2, Boolean flag) {
+ ImplicitConv result;
+
+ if (copts.old_argmatch)
+ return oldassignmentpromotion(expr, type2, qual2, flag);
+
+ if (ENODE_IS(expr, EMEMBER))
+ expr = getpointertomemberfunc(expr, type2, 1);
+
+ if (!CExpr_ImplicitConversionMatch(expr, type2, qual2, &result)) {
+ CError_Error(CErrorStr209, expr->rtype, ENODE_QUALS(expr), type2, qual2);
+ return nullnode();
+ }
+
+ return CExpr_Convert(expr, type2, qual2, 0, flag);
+}
+
+static Boolean CExpr_IsBetterMatch(Match *a, Match *b, int count) {
+ ImplicitConv *convA;
+ ImplicitConv *convB;
+ int i;
+ Boolean flag;
+
+ convA = a->conv;
+ convB = b->conv;
+ flag = 0;
+
+ if (convA->type != ICT_0 && convB->type != ICT_0) {
+ if (CExpr_IsBetterImplicitConv(convB, convA))
+ return 0;
+ if (CExpr_IsBetterImplicitConv(convA, convB))
+ flag = 1;
+ }
+
+ for (i = 0; i < count; i++) {
+ if (CExpr_IsBetterImplicitConv(++convB, ++convA))
+ return 0;
+ if (CExpr_IsBetterImplicitConv(convA, convB))
+ flag = 1;
+ }
+
+ if (flag)
+ return 1;
+
+ if (b->object) {
+ CError_ASSERT(2165, IS_TYPE_FUNC(b->object->type));
+ if (b->object->u.func.inst) {
+ if (!a->object)
+ return 1;
+
+ CError_ASSERT(2169, IS_TYPE_FUNC(a->object->type));
+ if (!a->object->u.func.inst)
+ return 1;
+
+ CError_ASSERT(2174, a->specialfunc && b->specialfunc);
+ if (CTempl_FuncIsMoreSpecialized(a->specialfunc, b->specialfunc))
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+static Boolean CExpr_MatchArgs(Object *func, ENodeList *argexprs, ENode *expr, ImplicitConv *convs) {
+ FuncArg *args;
+ ENode *newExpr;
+ Type *type;
+
+ args = TYPE_FUNC(func->type)->args;
+
+ if (!(TYPE_FUNC(func->type)->flags & FUNC_FLAGS_METHOD)) {
+ convs->type = ICT_0;
+ } else if (TYPE_METHOD(func->type)->x26) {
+ convs->type = ICT_0;
+ } else if (TYPE_FUNC(func->type)->flags & FUNC_FLAGS_1000) {
+ convs->type = ICT_0;
+ args = args->next;
+ } else {
+ if (!expr)
+ return 0;
+
+ newExpr = lalloc(sizeof(ENode));
+ newExpr->type = EINTCONST;
+ newExpr->cost = 0;
+ newExpr->flags = expr->flags;
+ newExpr->rtype = CDecl_NewPointerType(expr->rtype);
+ newExpr->data.intval = cint64_zero;
+
+ if (func->datatype == DALIAS) {
+ CError_ASSERT(2231, func->u.alias.member);
+ type = CDecl_NewPointerType(func->u.alias.member->type);
+ } else {
+ type = args->type;
+ }
+
+ if (!CExpr_ImplicitConversionMatch(newExpr, type, args->qual, convs))
+ return 0;
+ args = args->next;
+ }
+
+ convs++;
+ while (1) {
+ if (!args || args->type == &stvoid) {
+ if (argexprs)
+ return 0;
+ else
+ return 1;
+ }
+
+ if (args == &elipsis || args == &oldstyle) {
+ while (argexprs) {
+ convs->type = ICT_1;
+ argexprs = argexprs->next;
+ convs++;
+ }
+ return 1;
+ }
+
+ if (!argexprs)
+ return args->dexpr != NULL;
+
+ if (!CExpr_ImplicitConversionMatch(argexprs->node, args->type, args->qual, convs))
+ return 0;
+
+ argexprs = argexprs->next;
+ args = args->next;
+ convs++;
+ }
+}
+
+static Object *CExpr_GetMatchObject(Match *match, HashNameNode *name) {
+ Object *object;
+ FuncArg *arg;
+ TypeFunc *tfunc;
+
+ if (match->object)
+ return match->object;
+
+ tfunc = lalloc(sizeof(TypeFunc));
+ memclrw(tfunc, sizeof(TypeFunc));
+ tfunc->type = TYPEFUNC;
+ tfunc->functype = &stvoid;
+
+ arg = lalloc(sizeof(FuncArg));
+ memclrw(arg, sizeof(FuncArg));
+ arg->type = match->type;
+ arg->qual = match->qual;
+ tfunc->args = arg;
+
+ if (match->type2) {
+ arg = lalloc(sizeof(FuncArg));
+ memclrw(arg, sizeof(FuncArg));
+ arg->type = match->type2;
+ arg->qual = match->qual2;
+ tfunc->args->next = arg;
+ }
+
+ object = lalloc(sizeof(Object));
+ memclrw(object, sizeof(Object));
+ object->name = name;
+ object->datatype = DFUNC;
+ object->nspace = cscope_root;
+ object->type = TYPE(tfunc);
+ return object;
+}
+
+static Match *CExpr_FindBestMatch(Match *matches, int count, HashNameNode *name, ObjectList **outList, ENodeList *argExprs) {
+ Match *scan;
+ Match *best;
+ ObjectList *listHead;
+ ObjectList *list;
+
+ best = matches;
+ for (scan = matches->next; scan; scan = scan->next) {
+ if (CExpr_IsBetterMatch(scan, best, count))
+ best = scan;
+ }
+
+ for (scan = matches, listHead = NULL; scan; scan = scan->next) {
+ if (scan != best && !CExpr_IsBetterMatch(best, scan, count)) {
+ list = lalloc(sizeof(ObjectList));
+ list->next = listHead;
+ list->object = CExpr_GetMatchObject(scan, name);
+ listHead = list;
+ }
+ }
+
+ if (!outList) {
+ if (listHead)
+ CError_OverloadedFunctionError(CExpr_GetMatchObject(best, name), listHead);
+ } else {
+ *outList = listHead;
+ }
+
+ return best;
+}
+
+void CExpr_FuncArgMatch(NameSpaceObjectList *list, TemplArg *templargs, ENodeList *argexprs, Match13 *match13, ENode *expr, Boolean flag) {
+ NameSpaceObjectList *i;
+ NameSpaceObjectList *j;
+ Match *match;
+ Match *matches;
+ Object *object;
+ Object *object2;
+ Object *specialfunc;
+ ENodeList *argscan;
+ int argcount;
+
+ for (argscan = argexprs, argcount = 0; argscan; argscan = argscan->next) {
+ CDecl_CompleteType(argscan->node->rtype);
+ argcount++;
+ }
+
+ matches = NULL;
+ match = lalloc(sizeof(Match) + ((argcount - 2) * sizeof(ImplicitConv)));
+
+ for (i = list; i; i = i->next) {
+ object = OBJECT(i->object);
+ if (
+ object->otype == OT_OBJECT &&
+ IS_TYPE_FUNC(object->type) &&
+ (!flag || !(object->qual & Q_EXPLICIT))
+ )
+ {
+ if (object->datatype == DALIAS && (TYPE_FUNC(object->type)->flags & FUNC_FLAGS_METHOD)) {
+ for (j = list; j; j = j->next) {
+ if (j == i)
+ continue;
+
+ object2 = OBJECT(j->object);
+ if (
+ object2->otype == OT_OBJECT &&
+ IS_TYPE_METHOD(object2->type) &&
+ (TYPE_FUNC(object2->type)->flags & FUNC_FLAGS_CV) == (TYPE_FUNC(object->type)->flags & FUNC_FLAGS_CV)
+ )
+ {
+ FuncArg *argsA;
+ FuncArg *argsB;
+ argsA = TYPE_FUNC(object->type)->args;
+ if (argsA && !TYPE_METHOD(object->type)->x26)
+ argsA = argsA->next;
+ argsB = TYPE_FUNC(object2->type)->args;
+ if (argsB && !TYPE_METHOD(object2->type)->x26)
+ argsB = argsB->next;
+ if (is_arglistsame(argsA, argsB))
+ break;
+ }
+ }
+
+ if (j)
+ continue;
+ }
+
+ if (TYPE_FUNC(object->type)->flags & FUNC_FLAGS_100000) {
+ specialfunc = object;
+ object = CTempl_DeduceFromFunctionCall(object, templargs, argexprs);
+ if (!object)
+ continue;
+ } else {
+ if (templargs)
+ continue;
+ specialfunc = NULL;
+ }
+
+ if (CExpr_MatchArgs(object, argexprs, expr, match->conv)) {
+ match->object = object;
+ match->specialfunc = specialfunc;
+ match->next = matches;
+ matches = match;
+ match = lalloc(sizeof(Match) + ((argcount - 2) * sizeof(ImplicitConv)));
+ }
+ }
+ }
+
+ if (matches) {
+ matches = CExpr_FindBestMatch(matches, argcount, NULL, &match13->list, argexprs);
+ match13->obj = matches->object;
+ }
+}
+
+static ConversionTypeList *CExpr_BuildConversionTypeList(ENode *expr) {
+ ConversionTypeList *first;
+ ConversionTypeList *list;
+ Object *object;
+ Type *type;
+ ConversionIterator convIter;
+
+ if (!IS_TYPE_CLASS(expr->rtype)) {
+ first = lalloc(sizeof(ConversionTypeList));
+ first->next = NULL;
+ first->func = NULL;
+ first->type = expr->rtype;
+ first->qual = ENODE_QUALS(expr);
+ if (IS_TYPE_ENUM(first->type))
+ first->qual = 0;
+ } else {
+ first = NULL;
+ CExpr_ConversionIteratorInit(&convIter, TYPE_CLASS(expr->rtype));
+ while ((object = CExpr_ConversionIteratorNext(&convIter))) {
+ type = TYPE_FUNC(object->type)->functype;
+ if (IS_TYPE_REFERENCE(type))
+ type = TPTR_TARGET(type);
+
+ if (!IS_TYPE_CLASS(type)) {
+ list = lalloc(sizeof(ConversionTypeList));
+ list->next = first;
+ list->func = object;
+ list->type = type;
+ list->qual = TYPE_FUNC(object->type)->qual & Q_CV;
+ first = list;
+ }
+ }
+ }
+
+ return first;
+}
+
+static Type *CExpr_NextPromotedIntegralType(int *p) {
+ switch (++(*p)) {
+ case 1: return TYPE(&stsignedint);
+ case 2: return TYPE(&stunsignedint);
+ case 3: return TYPE(&stsignedlong);
+ case 4: return TYPE(&stunsignedlong);
+ case 5:
+ if (copts.longlong)
+ return TYPE(&stsignedlonglong);
+ else
+ return NULL;
+ case 6:
+ if (copts.longlong)
+ return TYPE(&stunsignedlonglong);
+ else
+ return NULL;
+ }
+
+ return NULL;
+}
+
+static Type *CExpr_NextArithmeticType(int *p) {
+ switch (++(*p)) {
+ case 1: return TYPE(&stbool);
+ case 2: return TYPE(&stchar);
+ case 3: return TYPE(&stsignedchar);
+ case 4: return TYPE(&stunsignedchar);
+ case 5: return TYPE(&stwchar);
+ case 6: return TYPE(&stsignedshort);
+ case 7: return TYPE(&stunsignedshort);
+ case 8: return TYPE(&stsignedint);
+ case 9: return TYPE(&stunsignedint);
+ case 10: return TYPE(&stsignedlong);
+ case 11: return TYPE(&stunsignedlong);
+ case 12: return TYPE(&stfloat);
+ case 13: return TYPE(&stdouble);
+ case 14: return TYPE(&stlongdouble);
+ case 15:
+ if (copts.longlong)
+ return TYPE(&stsignedlonglong);
+ else
+ return NULL;
+ case 16:
+ if (copts.longlong)
+ return TYPE(&stunsignedlonglong);
+ else
+ return NULL;
+ }
+
+ return NULL;
+}
+
+static Type *CExpr_NextPromotedArithmeticType(int *p) {
+ switch (++(*p)) {
+ case 1: return TYPE(&stsignedint);
+ case 2: return TYPE(&stunsignedint);
+ case 3: return TYPE(&stsignedlong);
+ case 4: return TYPE(&stunsignedlong);
+ case 5: return TYPE(&stdouble);
+ case 6: return TYPE(&stlongdouble);
+ case 7:
+ if (copts.longlong)
+ return TYPE(&stsignedlonglong);
+ else
+ return NULL;
+ case 8:
+ if (copts.longlong)
+ return TYPE(&stunsignedlonglong);
+ else
+ return NULL;
+ }
+
+ return NULL;
+}
+
+static Match *CExpr_MatchBuiltin(Match *matches, ENode *left, Type *leftType, UInt32 leftQual, ENode *right, Type *rightType, UInt32 rightQual) {
+ Match *scan;
+ Match mymatch;
+
+ if (CExpr_ImplicitConversionMatch(left, leftType, leftQual, &mymatch.conv[0])) {
+ if (!right || CExpr_ImplicitConversionMatch(right, rightType, rightQual, &mymatch.conv[1])) {
+ if (right) {
+ for (scan = matches; scan; scan = scan->next) {
+ if (
+ !scan->object &&
+ is_typesame(scan->type, leftType) &&
+ scan->qual == leftQual &&
+ is_typesame(scan->type2, rightType) &&
+ scan->qual2 == rightQual
+ )
+ return matches;
+ }
+ }
+
+ mymatch.next = matches;
+ mymatch.object = NULL;
+ mymatch.specialfunc = NULL;
+ mymatch.type = leftType;
+ mymatch.qual = leftQual;
+ mymatch.type2 = rightType;
+ mymatch.qual2 = rightQual;
+
+ matches = lalloc(sizeof(Match));
+ *matches = mymatch;
+ }
+ }
+
+ return matches;
+}
+
+static Match *CExpr_CheckIncDecBuiltin(Match *matches, short token, ENode *expr1, ENode *expr2) {
+ Object *object;
+ Type *type;
+ TypeFunc *tfunc;
+ ConversionIterator convIter;
+
+ if (IS_TYPE_CLASS(expr1->rtype)) {
+ CExpr_ConversionIteratorInit(&convIter, TYPE_CLASS(expr1->rtype));
+ while ((object = CExpr_ConversionIteratorNext(&convIter))) {
+ tfunc = TYPE_FUNC(object->type);
+ if (IS_TYPE_REFERENCE(tfunc->functype)) {
+ type = TPTR_TARGET(tfunc->functype);
+ switch (type->type) {
+ case TYPEINT:
+ if (type == TYPE(&stbool) && token == TK_DECREMENT)
+ break;
+ case TYPEFLOAT:
+ case TYPEPOINTER:
+ if (!CParser_IsConst(type, tfunc->qual)) {
+ matches = CExpr_MatchBuiltin(
+ matches,
+ expr1, type, tfunc->qual,
+ expr2, expr2 ? TYPE(&stsignedint) : NULL, 0
+ );
+ }
+ break;
+ }
+ }
+ }
+ }
+
+ return matches;
+}
+
+static Match *CExpr_CheckUnaryBuiltin(Match *matches, short token, ENode *expr) {
+ ConversionTypeList *typelist;
+ Type *type;
+ int typenum;
+
+ switch (token) {
+ case TK_INCREMENT:
+ case TK_DECREMENT:
+ return CExpr_CheckIncDecBuiltin(matches, token, expr, NULL);
+
+ case '!':
+ matches = CExpr_MatchBuiltin(matches, expr, TYPE(&stbool), 0, NULL, NULL, 0);
+ break;
+
+ case '~':
+ typenum = 0;
+ while ((type = CExpr_NextPromotedIntegralType(&typenum))) {
+ matches = CExpr_MatchBuiltin(matches, expr, type, 0, NULL, NULL, 0);
+ }
+ break;
+
+ case '*':
+ case '+':
+ for (typelist = CExpr_BuildConversionTypeList(expr); typelist; typelist = typelist->next) {
+ if (IS_TYPE_POINTER_ONLY(typelist->type))
+ matches = CExpr_MatchBuiltin(matches, expr, typelist->type, typelist->qual, NULL, NULL, 0);
+ }
+ if (token != '+')
+ break;
+
+ case '-':
+ typenum = 0;
+ while ((type = CExpr_NextPromotedArithmeticType(&typenum))) {
+ matches = CExpr_MatchBuiltin(matches, expr, type, 0, NULL, NULL, 0);
+ }
+ break;
+ }
+
+ return matches;
+}
+
+static Match *CExpr_CheckBinaryBuiltin(Match *matches, ENode *left, short token, ENode *right) {
+ int typenum1;
+ int typenum2;
+ Type *type1;
+ Type *type2;
+ Type *ptrdiff;
+ Boolean allowPtrDiffOnRight;
+ Boolean allowPtrCV;
+ Boolean allowPtrDiffOnLeft;
+ Boolean allowMemberPtrs;
+ Boolean allowEnum;
+ ConversionTypeList *leftList;
+ ConversionTypeList *rightList;
+ ConversionTypeList *scan;
+
+ switch (token) {
+ case TK_INCREMENT:
+ case TK_DECREMENT:
+ return CExpr_CheckIncDecBuiltin(matches, token, left, right);
+
+ case '*':
+ case '+':
+ case '-':
+ case '/':
+ case ':':
+ case '<':
+ case '>':
+ case TK_LOGICAL_EQ:
+ case TK_LOGICAL_NE:
+ case TK_LESS_EQUAL:
+ case TK_GREATER_EQUAL:
+ typenum1 = 0;
+ while ((type1 = CExpr_NextPromotedArithmeticType(&typenum1))) {
+ typenum2 = 0;
+ while ((type2 = CExpr_NextPromotedArithmeticType(&typenum2))) {
+ matches = CExpr_MatchBuiltin(matches, left, type1, 0, right, type2, 0);
+ }
+ }
+ break;
+
+ case '%':
+ case '&':
+ case '^':
+ case '|':
+ case TK_SHL:
+ case TK_SHR:
+ typenum1 = 0;
+ while ((type1 = CExpr_NextPromotedIntegralType(&typenum1))) {
+ typenum2 = 0;
+ while ((type2 = CExpr_NextPromotedIntegralType(&typenum2))) {
+ matches = CExpr_MatchBuiltin(matches, left, type1, 0, right, type2, 0);
+ }
+ }
+ return matches;
+
+ case TK_LOGICAL_OR:
+ case TK_LOGICAL_AND:
+ return CExpr_MatchBuiltin(matches, left, TYPE(&stbool), 0, right, TYPE(&stbool), 0);
+ }
+
+ allowEnum = 0;
+ allowMemberPtrs = 0;
+ allowPtrCV = 0;
+ allowPtrDiffOnLeft = 0;
+ allowPtrDiffOnRight = 0;
+
+ switch (token) {
+ case '+':
+ case '[':
+ allowPtrDiffOnLeft = 1;
+ allowPtrDiffOnRight = 1;
+ break;
+ case '-':
+ allowPtrCV = 1;
+ allowPtrDiffOnRight = 1;
+ break;
+ case ':':
+ case TK_LOGICAL_EQ:
+ case TK_LOGICAL_NE:
+ allowMemberPtrs = 1;
+ case '<':
+ case '>':
+ case TK_LESS_EQUAL:
+ case TK_GREATER_EQUAL:
+ allowPtrCV = 1;
+ allowEnum = 1;
+ break;
+ default:
+ return matches;
+ }
+
+ leftList = CExpr_BuildConversionTypeList(left);
+ rightList = CExpr_BuildConversionTypeList(right);
+ ptrdiff = CABI_GetPtrDiffTType();
+
+ for (scan = leftList; ; scan = scan->next) {
+ if (!scan) {
+ scan = rightList;
+ if (!rightList)
+ break;
+ rightList = NULL;
+ }
+
+ type1 = scan->type;
+ if (IS_TYPE_REFERENCE(type1))
+ type1 = TPTR_TARGET(type1);
+
+ switch (type1->type) {
+ case TYPEENUM:
+ if (allowEnum)
+ matches = CExpr_MatchBuiltin(matches, left, type1, scan->qual, right, type1, scan->qual);
+ break;
+
+ case TYPEPOINTER:
+ if (allowPtrDiffOnRight)
+ matches = CExpr_MatchBuiltin(matches, left, type1, scan->qual, right, ptrdiff, 0);
+ if (allowPtrDiffOnLeft)
+ matches = CExpr_MatchBuiltin(matches, left, ptrdiff, 0, right, type1, scan->qual);
+ if (allowPtrCV) {
+ if (IS_TYPE_POINTER_ONLY(TPTR_TARGET(type1))) {
+ type2 = galloc(sizeof(TypePointer));
+ *TYPE_POINTER(type2) = *TYPE_POINTER(type1);
+ TPTR_QUAL(type2) |= Q_CONST | Q_VOLATILE;
+ matches = CExpr_MatchBuiltin(matches, left, type2, scan->qual, right, type2, scan->qual);
+ } else {
+ matches = CExpr_MatchBuiltin(matches, left, type1, Q_CONST | Q_VOLATILE, right, type1, Q_CONST | Q_VOLATILE);
+ }
+ }
+ break;
+
+ case TYPEMEMBERPOINTER:
+ if (allowMemberPtrs)
+ matches = CExpr_MatchBuiltin(matches, left, type1, scan->qual, right, type1, scan->qual);
+ break;
+ }
+ }
+
+ return matches;
+}
+
+static Boolean CExpr_MatchOperands(ENode *left, Type *leftType, UInt32 leftQual, ENode *right, Type *rightType, UInt32 rightQual, ImplicitConv *twoResults, Boolean flag) {
+ if (flag) {
+ if (!CExpr_StandardConversionMatch(left, leftType, leftQual, 1, &twoResults[0].u.ic3.standardConv))
+ return 0;
+ twoResults[0].type = ICT_3;
+ } else {
+ if (!CExpr_ImplicitConversionMatch(left, leftType, leftQual, &twoResults[0]))
+ return 0;
+ }
+
+ if (right) {
+ if (!CExpr_ImplicitConversionMatch(right, rightType, rightQual, &twoResults[1]))
+ return 0;
+ }
+
+ return 1;
+}
+
+Boolean CExpr_CondOperatorMatch(ENode *left, ENode *right, Conversion *conv) {
+ Match *match;
+
+ if ((match = CExpr_CheckBinaryBuiltin(NULL, left, ':', right))) {
+ match = CExpr_FindBestMatch(match, 1, GetHashNameNode("operator?:"), NULL, NULL);
+ CError_ASSERT(2931, !match->object);
+
+ conv->x0 = NULL;
+ conv->left = CExpr_Convert(left, match->type, match->qual, 0, 1);
+ conv->right = CExpr_Convert(right, match->type2, match->qual2, 0, 1);
+ return 1;
+ }
+
+ return 0;
+}
+
+Boolean CExpr_OperatorMatch(short token, ENode *left, ENode *right, Conversion *conv) {
+ HashNameNode *name;
+ ENodeList *argExprs;
+ BClassList *path;
+ int hasArg;
+ Match *matches;
+ Object *object;
+ Object *specialfunc;
+ NameSpaceObjectList *list;
+ Type *leftType;
+ UInt32 leftQual;
+ Type *rightType;
+ UInt32 rightQual;
+ CScopeParseResult pr;
+ NameSpaceObjectList myList;
+ Match myMatch;
+
+ if (!IS_TYPE_CLASS(left->rtype)) {
+ if (!IS_TYPE_ENUM(left->rtype)) {
+ if (!right || !(IS_TYPE_CLASS(right->rtype) || IS_TYPE_ENUM(right->rtype)))
+ return 0;
+ }
+ } else {
+ CDecl_CompleteType(left->rtype);
+ }
+
+ name = CMangler_OperatorName(token);
+ path = NULL;
+
+ argExprs = lalloc(sizeof(ENodeList));
+ argExprs->node = left;
+ if (right) {
+ argExprs->next = lalloc(sizeof(ENodeList));
+ argExprs->next->node = right;
+ argExprs->next->next = NULL;
+ hasArg = 1;
+ } else {
+ argExprs->next = NULL;
+ hasArg = 0;
+ }
+
+ matches = NULL;
+
+ if (IS_TYPE_CLASS(left->rtype) && CScope_FindClassMemberObject(TYPE_CLASS(left->rtype), &pr, name)) {
+ if (token != '=' || (pr.bcl_18->type == left->rtype && !pr.bcl_18->next)) {
+ if (pr.obj_10) {
+ myList.next = NULL;
+ myList.object = pr.obj_10;
+ pr.nsol_14 = &myList;
+ } else {
+ CError_ASSERT(3009, pr.nsol_14);
+ }
+
+ for (list = pr.nsol_14; list; list = list->next) {
+ object = OBJECT(list->object);
+ if (object->otype == OT_OBJECT && IS_TYPE_FUNC(object->type)) {
+ if (TYPE_FUNC(object->type)->flags & FUNC_FLAGS_100000) {
+ specialfunc = object;
+ object = CTempl_DeduceFromFunctionCall(object, NULL, argExprs->next);
+ if (!object)
+ continue;
+ } else {
+ specialfunc = NULL;
+ }
+
+ leftType = CExpr_GetImplictObjectParamType(object, &leftQual);
+ if (right) {
+ if (!CExpr_HasNParams(object, 1))
+ continue;
+ rightType = CExpr_GetParamType(object, 0, &rightQual);
+ } else {
+ if (!CExpr_HasNParams(object, 0))
+ continue;
+ }
+
+ if (CExpr_MatchOperands(left, leftType, leftQual, right, rightType, rightQual, myMatch.conv, 1)) {
+ myMatch.object = object;
+ myMatch.specialfunc = specialfunc;
+ myMatch.next = matches;
+ matches = lalloc(sizeof(Match));
+ *matches = myMatch;
+ path = pr.bcl_18;
+ }
+ }
+ }
+ }
+ }
+
+ if (CScope_FindNonClassObject(cscope_current, &pr, name)) {
+ if (pr.obj_10) {
+ myList.next = NULL;
+ myList.object = pr.obj_10;
+ pr.nsol_14 = &myList;
+ }
+ } else {
+ pr.nsol_14 = NULL;
+ }
+
+ if (copts.arg_dep_lookup)
+ pr.nsol_14 = CScope_ArgumentDependentNameLookup(pr.nsol_14, name, argExprs, 1);
+
+ for (list = pr.nsol_14; list; list = list->next) {
+ object = OBJECT(list->object);
+ if (object->otype == OT_OBJECT && IS_TYPE_NONMETHOD(object->type)) {
+ if (TYPE_FUNC(object->type)->flags & FUNC_FLAGS_100000) {
+ specialfunc = object;
+ object = CTempl_DeduceFromFunctionCall(object, NULL, argExprs);
+ if (!object)
+ continue;
+ } else {
+ specialfunc = NULL;
+ }
+
+ leftType = CExpr_GetParamType(object, 0, &leftQual);
+ if (right) {
+ if (!CExpr_HasNParams(object, 2))
+ continue;
+ rightType = CExpr_GetParamType(object, 1, &rightQual);
+ } else {
+ if (!CExpr_HasNParams(object, 1))
+ continue;
+ }
+
+ if (CExpr_MatchOperands(left, leftType, leftQual, right, rightType, rightQual, myMatch.conv, 0)) {
+ myMatch.object = object;
+ myMatch.specialfunc = specialfunc;
+ myMatch.next = matches;
+ matches = lalloc(sizeof(Match));
+ *matches = myMatch;
+ }
+ }
+ }
+
+ if (right)
+ matches = CExpr_CheckBinaryBuiltin(matches, left, token, right);
+ else
+ matches = CExpr_CheckUnaryBuiltin(matches, token, left);
+
+ if (matches) {
+ conv->x0 = NULL;
+ conv->left = NULL;
+ conv->right = NULL;
+
+ matches = CExpr_FindBestMatch(matches, hasArg, name, NULL, argExprs);
+ object = matches->object;
+ if (!object) {
+ if (IS_TYPE_CLASS(left->rtype))
+ conv->left = CExpr_Convert(left, matches->type, matches->qual, 0, 1);
+ else
+ conv->left = left;
+
+ if (right) {
+ if (IS_TYPE_CLASS(right->rtype))
+ conv->right = CExpr_Convert(right, matches->type2, matches->qual2, 0, 1);
+ else
+ conv->right = right;
+ }
+
+ return 1;
+ }
+
+ if (IS_TYPEFUNC_NONSTATIC_METHOD(TYPE_FUNC(object->type))) {
+ CError_ASSERT(3125, path);
+ left = CExpr_GenericFuncCall(path, argExprs->node, 0, object, NULL, NULL, argExprs->next, 0, 0, 1);
+ } else {
+ left = CExpr_GenericFuncCall(NULL, NULL, 0, object, NULL, NULL, argExprs, 0, 0, 1);
+ }
+
+ conv->x0 = checkreference(left);
+ return 1;
+ }
+
+ return 0;
+}
+
+static ENode *CExpr_ClassCopyInit(TypeClass *tclass, ENode *expr1, ENode *expr2) {
+ Object *best;
+ NameSpaceObjectList *list;
+ ObjectList *objlist;
+ ObjectList *objlistEntry;
+ ENodeList *argExprs;
+ FuncArg *arg;
+ Type *type;
+ Object *object;
+ ImplicitConv bestConv;
+ ImplicitConv conv;
+ BClassList path;
+ ConversionIterator convIter;
+
+ best = NULL;
+ objlist = NULL;
+
+ for (list = CClass_Constructor(tclass); list; list = list->next) {
+ object = OBJECT(list->object);
+ if (object->otype == OT_OBJECT && IS_TYPE_FUNC(object->type) && !(object->qual & Q_EXPLICIT)) {
+ arg = TYPE_FUNC(object->type)->args;
+
+ CError_ASSERT(3199, arg);
+ arg = arg->next;
+
+ if (tclass->flags & CLASS_FLAGS_20) {
+ CError_ASSERT(3203, arg);
+ arg = arg->next;
+ }
+
+ if (
+ arg &&
+ arg != &elipsis &&
+ (!arg->next || arg->next->dexpr) &&
+ CExpr_ImplicitConversionMatch(expr2, arg->type, arg->qual, &conv)
+ )
+ {
+ if (!best || CExpr_IsBetterImplicitConv(&conv, &bestConv)) {
+ best = object;
+ bestConv = conv;
+ objlist = NULL;
+ } else if (!CExpr_IsBetterImplicitConv(&bestConv, &conv)) {
+ objlistEntry = lalloc(sizeof(ObjectList));
+ objlistEntry->next = objlist;
+ objlistEntry->object = object;
+ objlist = objlistEntry;
+ }
+ }
+ }
+ }
+
+ if (IS_TYPE_CLASS(expr2->rtype)) {
+ CExpr_ConversionIteratorInit(&convIter, TYPE_CLASS(expr2->rtype));
+ while ((object = CExpr_ConversionIteratorNext(&convIter))) {
+ type = TYPE_FUNC(object->type)->functype;
+ if (IS_TYPE_REFERENCE(type))
+ type = TPTR_TARGET(type);
+
+ if (
+ IS_TYPE_CLASS(type) &&
+ (tclass == TYPE_CLASS(type) || CClass_IsBaseClass(tclass, TYPE_CLASS(type), NULL, 0, 0))
+ )
+ {
+ CError_ASSERT(3248, TYPE_FUNC(object->type)->args &&
+ IS_TYPE_POINTER_ONLY(TYPE_FUNC(object->type)->args->type));
+
+ type = galloc(sizeof(TypePointer));
+ *TYPE_POINTER(type) = *TYPE_POINTER(TYPE_FUNC(object->type)->args->type);
+ TPTR_QUAL(type) = Q_REFERENCE;
+ if (CExpr_ImplicitConversionMatch(expr2, type, TYPE_FUNC(object->type)->args->qual, &conv)) {
+ if (!best || CExpr_IsBetterImplicitConv(&conv, &bestConv)) {
+ best = object;
+ bestConv = conv;
+ objlist = NULL;
+ } else if (!CExpr_IsBetterImplicitConv(&bestConv, &conv)) {
+ objlistEntry = lalloc(sizeof(ObjectList));
+ objlistEntry->next = objlist;
+ objlistEntry->object = object;
+ objlist = objlistEntry;
+ }
+ }
+ }
+ }
+ }
+
+ if (objlist)
+ CError_OverloadedFunctionError(best, objlist);
+
+ if (!best) {
+ CError_Error(CErrorStr209, expr2->rtype, ENODE_QUALS(expr2), tclass, 0);
+ return expr1;
+ }
+
+ CError_ASSERT(3284, IS_TYPE_POINTER_ONLY(expr1->rtype));
+
+ expr1 = makemonadicnode(expr1, EINDIRECT);
+ expr1->rtype = TYPE(tclass);
+
+ argExprs = lalloc(sizeof(ENodeList));
+ argExprs->node = expr2;
+ if (tclass->flags & CLASS_FLAGS_20) {
+ argExprs->next = lalloc(sizeof(ENodeList));
+ argExprs->next->next = NULL;
+ argExprs->next->node = intconstnode(TYPE(&stsignedshort), 1);
+ } else {
+ argExprs->next = NULL;
+ }
+
+ path.next = NULL;
+ path.type = TYPE(tclass);
+ expr1 = CExpr_GenericFuncCall(&path, expr1, 0, best, NULL, NULL, argExprs, 0, 0, 1);
+
+ if (ENODE_IS2(expr1, EFUNCCALL, EFUNCCALLP))
+ expr1->rtype = CDecl_NewPointerType(TYPE(tclass));
+
+ expr1 = makemonadicnode(expr1, EINDIRECT);
+ expr1->rtype = TYPE(tclass);
+ return expr1;
+}
diff --git a/compiler_and_linker/unsorted/CFunc.c b/compiler_and_linker/unsorted/CFunc.c
index 780dbd2..94a2c9e 100644
--- a/compiler_and_linker/unsorted/CFunc.c
+++ b/compiler_and_linker/unsorted/CFunc.c
@@ -1,6 +1,73 @@
#include "compiler/CFunc.h"
+#include "compiler/CABI.h"
+#include "compiler/CClass.h"
+#include "compiler/CDecl.h"
+#include "compiler/CError.h"
+#include "compiler/CException.h"
+#include "compiler/CExpr.h"
+#include "compiler/CInit.h"
+#include "compiler/CInline.h"
+#include "compiler/CInt64.h"
+#include "compiler/CMachine.h"
+#include "compiler/CMangler.h"
+#include "compiler/CParser.h"
+#include "compiler/CPrepTokenizer.h"
+#include "compiler/CSOM.h"
+#include "compiler/CTemplateTools.h"
+#include "compiler/CodeGen.h"
+#include "compiler/CompilerTools.h"
+#include "compiler/Exceptions.h"
+#include "compiler/FuncLevelAsmPPC.h"
+#include "compiler/InlineAsmPPC.h"
+#include "compiler/ObjGenMachO.h"
+#include "compiler/Switch.h"
+#include "compiler/objects.h"
+#include "compiler/scopes.h"
#include "compiler/types.h"
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+struct CFuncSave {
+ CScopeSave scope;
+ ObjectList *arguments;
+ ObjectList *locals;
+ CLabel *labels;
+ Statement *curstmt;
+ DeclBlock *firstblock;
+ DeclBlock *currentblock;
+ ExceptionAction *cexcept_dobjstack;
+ CLabel *sinit_label;
+ ENode *ainit_expr;
+ CtorChain *ctor_chain;
+ ParserTryBlock *trychain;
+ TempNodeCB cinit_tempnodefunc;
+ HashNameNode *tkidentifier;
+ Object *sinit_first_object;
+ FileOffsetInfo cparser_fileoffset;
+ TStreamElement symdecltoken;
+ SInt32 functionbodyoffset;
+ HashNameNode *functionbodypath;
+ SInt32 symdecloffset;
+ SInt32 symdeclend;
+ SInt32 sourceoffset;
+ HashNameNode *sourcefilepath;
+ SInt32 curstmtvalue;
+ NameObjCheckCB name_obj_check;
+ FuncArg *check_arglist;
+ short blockcount;
+ short localcount;
+ short tk;
+ AccessType global_access;
+ Boolean cexcept_hasdobjects;
+ Boolean ainit_only_one;
+ Boolean cfunc_is_extern_c;
+ Boolean temp_reference_init;
+};
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
FuncArg elipsis;
FuncArg oldstyle;
ObjectList *arguments;
@@ -31,75 +98,3127 @@ static short cfunc_staticvarcount;
static void *destroyobjects;
static Boolean cfunc_hasdtortemp;
-static void CFunc_LoopIncrement(void) {}
-static void CFunc_LoopDecrement(void) {}
-DeclBlock *CFunc_NewDeclBlock(void) {}
-void CFunc_RestoreBlock(DeclBlock *block) {}
-void CFunc_SetupLocalVarInfo(Object *obj) {}
-static void adjustargumenttype(DeclInfo *declinfo) {}
-static FuncArg *CFunc_IsInArgList(FuncArg *list, HashNameNode *name) {}
-static Object *CFunc_IsInObjList(ObjectList *list, HashNameNode *name) {}
-static void CFunc_AppendArg(FuncArg **list, FuncArg *arg) {}
-static void identifier_list(DeclInfo *declinfo) {}
-static Boolean defarg_name_obj_check(HashNameNode *name, Object *obj) {}
-void CFunc_DefaultArg(Type *type, short qual, FuncArg *args) {}
-static FuncArg *parameter_list(DeclInfo *declinfo) {}
-Boolean CFunc_ParseFakeArgList(Boolean flag) {}
-FuncArg *parameter_type_list(DeclInfo *declinfo) {}
-CLabel *findlabel(void) {}
-CLabel *newlabel(void) {}
-Statement *CFunc_AppendStatement(StatementType sttype) {}
-Statement *CFunc_InsertStatement(StatementType sttype, Statement *after) {}
-Statement *CFunc_InsertBeforeStatement(StatementType sttype, Statement *before) {}
-void CheckCLabels(void) {}
-Object *create_temp_object(Type *type) {}
-ENode *create_temp_node(Type *type) {}
-ENode *create_temp_node2(Type *type) {}
-static void CFunc_DestroyReverse() {} // not sure about type
-static void CFunc_TempTransDestroy() {} // not sure about type
-void CFunc_WarnUnused(void) {}
-void CFunc_CodeCleanup(Statement *stmt) {}
-static Boolean DestructorNeeded(ExceptionAction *a, ExceptionAction *b) {}
-static Statement *DestructLocals(Statement *stmt, ExceptionAction *exc1, ExceptionAction *exc2) {}
-static Boolean NeedsDestruction(Statement *stmt1, Statement *stmt2) {}
-static ExceptionAction *FindLastNonCommonStackObj(Statement *stmt1, Statement *stmt2) {}
-static void DestructorReturnTransform(Statement *stmt1, Statement *stmt2) {}
-static Statement *DestructorIfTransform(Statement *stmt) {}
-static Boolean IsSubStack(ExceptionAction *exc1, ExceptionAction *exc2) {}
-static void CFunc_CheckInitSkip(Statement *stmt, ExceptionAction *exc) {}
-void CFunc_DestructorCleanup(Statement *stmt) {}
-static void scancase(DeclThing *thing) {}
-static void CFunc_NameLocalStaticDataObject(Object *obj, char *str) {}
-static void sinit_insert_expr(ENode *expr) {}
-static void ainit_insert_expr(ENode *expr) {}
-static ENode *ainit_register_object(TypeClass *tclass, Object *local, SInt32 offset, void *unk) {}
-static void CFunc_LocalDataDeclarator(DeclInfo *declinfo, TStreamElement *element, Boolean flag1, Boolean flag2) {}
-static ENode *CFunc_ParseLocalDeclarationList(Boolean flag1, Boolean flag2, Boolean flag3, Boolean flag4) {}
-static void makeifstatement(ENode *expr, CLabel *label1, CLabel *label2, Boolean flag1, Boolean flag2) {}
-static void CFunc_HasDtorTempCallBack(ENode *expr) {}
-static void ifstatement(Boolean flag1, ENode *expr, CLabel *label, Boolean flag2) {}
-Statement *CFunc_GenerateLoop(Statement *stmt, Type *type, ENode *expr1, ENode *expr2, ENode *expr3, ENode *expr4, ENode (*callback)(ENode *, ENode *)) {}
-static Boolean checklabel(void) {}
-static ENode *returnstatementadjust(ENode *expr, Type *type, UInt32 qual) {}
-static void CFunc_AutoResultCheck(ENode *expr) {}
-static void statement(DeclThing *thing) {}
-void CFunc_CompoundStatement(DeclThing *thing) {}
-static void CFunc_InsertArgumentCopyConversion(Object *obj, Type *type1, Type *type2, Boolean flag) {}
-static void CFunc_AdjustOldStyleArgs(void) {}
-void CFunc_SetupNewFuncArgs(Object *obj, FuncArg *args) {}
-static ObjectList *CFunc_CopyObjectList(ObjectList *list) {}
-static void SetupFunctionArguments(Object *obj, DeclInfo *declinfo) {}
-NameSpace *CFunc_FuncGenSetup(Statement *stmt, Object *func) {}
-void CFunc_GetGlobalCompilerState(CFuncSave *state) {}
-void CFunc_SetGlobalCompilerState(CFuncSave *state) {}
-void CFunc_Gen(Statement *stmt, Object *obj, UInt8 unk) {}
-static void CFunc_CheckCtorInitializer(TypeClass *tclass, CtorChain *chain) {}
-void CFunc_CheckClassCtors(TypeClass *tclass) {}
-static void CFunc_ParseCtorInitializer(void) {}
-static void CFunc_FunctionRedefinedCheck(Object *obj) {}
-static Object *CFunc_DeclareFuncName(char *str, HashNameNode *name) {}
-void CFunc_ParseFuncDef(Object *obj, DeclInfo *declinfo, TypeClass *tclass, Boolean is_method, Boolean is_static, NameSpace *nspace) {}
-void InitExpr_Register(ENode *expr, Object *object) {}
-void CFunc_GenerateDummyFunction(Object *a) {}
-void CFunc_GenerateSingleExprFunc(Object *a, ENode *expr) {}
-void CFunc_GenerateDummyCtorFunc(Object *a, Object *b) {}
+// forward decls
+static void statement(DeclThing *thing);
+
+static void CFunc_LoopIncrement(void) {
+ if (curstmtvalue >= 0x1000) {
+ if (curstmtvalue >= 0xF000)
+ curstmtvalue++;
+ else
+ curstmtvalue += 0x1000;
+ } else {
+ curstmtvalue <<= 3;
+ }
+}
+
+static void CFunc_LoopDecrement(void) {
+ if (curstmtvalue > 0x1000) {
+ if (curstmtvalue > 0xF000)
+ curstmtvalue--;
+ else
+ curstmtvalue -= 0x1000;
+ } else {
+ curstmtvalue >>= 3;
+ }
+
+ if (curstmtvalue < 1)
+ curstmtvalue = 1;
+}
+
+DeclBlock *CFunc_NewDeclBlock(void) {
+ DeclBlock *block;
+ NameSpace *nspace;
+
+ block = lalloc(sizeof(DeclBlock));
+ if (firstblock) {
+ currentblock->next = block;
+ currentblock = block;
+ } else {
+ firstblock = block;
+ currentblock = block;
+ }
+
+ block->index = blockcount++;
+ block->parent_nspace = cscope_current;
+ block->dobjstack = cexcept_dobjstack;
+
+ nspace = CScope_NewListNameSpace(NULL, 0);
+ nspace->parent = cscope_current;
+ cscope_current = nspace;
+
+ return block;
+}
+
+void CFunc_RestoreBlock(DeclBlock *block) {
+ if (curstmt && curstmt->dobjstack != cexcept_dobjstack) {
+ Statement *stmt = CFunc_AppendStatement(ST_EXPRESSION);
+ stmt->expr = nullnode();
+ }
+
+ cscope_current = block->parent_nspace;
+ cexcept_dobjstack = block->dobjstack;
+}
+
+void CFunc_SetupLocalVarInfo(Object *obj) {
+ obj->u.var.info = CodeGen_GetNewVarInfo();
+ obj->u.var.info->func = cscope_currentfunc;
+
+ if (obj->sclass == TK_REGISTER) {
+ if (!copts.optimize_for_size)
+ obj->u.var.info->usage = 100;
+ else
+ obj->u.var.info->usage = 5;
+ }
+
+ if (obj->type && is_volatile_object(obj))
+ obj->u.var.info->noregister = 1;
+}
+
+static void adjustargumenttype(DeclInfo *declinfo) {
+ switch (declinfo->thetype->type) {
+ case TYPECLASS:
+ if (TYPE_CLASS(declinfo->thetype)->sominfo) {
+ CError_Error(CErrorStr284);
+ declinfo->thetype = TYPE(&stsignedint);
+ }
+ break;
+ case TYPEFUNC:
+ makethetypepointer(declinfo, 0);
+ return;
+ case TYPEARRAY:
+ declinfo->thetype = CDecl_NewPointerType(TPTR_TARGET(declinfo->thetype));
+ return;
+ case TYPETEMPLATE:
+ if (TYPE_TEMPLATE(declinfo->thetype)->dtype == TEMPLDEP_ARRAY)
+ declinfo->thetype = CDecl_NewPointerType(TYPE_TEMPLATE(declinfo->thetype)->u.array.type);
+ return;
+ }
+
+ if (!CanCreateObject(declinfo->thetype))
+ declinfo->thetype = TYPE(&stsignedint);
+}
+
+static FuncArg *CFunc_IsInArgList(FuncArg *list, HashNameNode *name) {
+ while (list) {
+ if (name == list->name)
+ return list;
+ list = list->next;
+ }
+
+ return NULL;
+}
+
+static Object *CFunc_IsInObjList(ObjectList *list, HashNameNode *name) {
+ while (list) {
+ if (name == list->object->name)
+ return list->object;
+ list = list->next;
+ }
+
+ return NULL;
+}
+
+static void CFunc_AppendArg(FuncArg **list, FuncArg *arg) {
+ FuncArg *tail;
+
+ if ((tail = *list)) {
+ while (tail->next)
+ tail = tail->next;
+ tail->next = arg;
+ } else {
+ *list = arg;
+ }
+}
+
+static void identifier_list(DeclInfo *declinfo) {
+ FuncArg *arg;
+
+ declinfo->x45 = 1;
+
+ while (1) {
+ if (tk != TK_IDENTIFIER) {
+ CError_Error(CErrorStr121);
+ } else {
+ if (CFunc_IsInArgList(declinfo->x18, tkidentifier))
+ CError_Error(CErrorStr122, tkidentifier->name);
+
+ arg = CParser_NewFuncArg();
+ arg->name = tkidentifier;
+ CFunc_AppendArg(&declinfo->x18, arg);
+ declinfo->x44 = 1;
+ }
+
+ if ((tk = lex()) != ',')
+ break;
+ tk = lex();
+ }
+}
+
+static Boolean defarg_name_obj_check(HashNameNode *name, Object *obj) {
+ FuncArg *arg;
+
+ if (name) {
+ for (arg = check_arglist; arg; arg = arg->next) {
+ if (arg->name == name) {
+ CError_Error(CErrorStr205);
+ return 0;
+ }
+ }
+ }
+
+ if (obj && obj->datatype == DLOCAL) {
+ CError_Error(CErrorStr205);
+ return 0;
+ }
+
+ return 1;
+}
+
+ENode *CFunc_DefaultArg(Type *type, UInt32 qual, FuncArg *args) {
+ TStreamElement *element;
+ ENode *expr;
+ ENode *templdepexpr;
+
+ name_obj_check = defarg_name_obj_check;
+ check_arglist = args;
+ expr = conv_assignment_expression();
+ name_obj_check = NULL;
+
+ if (
+ !CTemplTool_IsTemplateArgumentDependentExpression(expr) &&
+ !CTemplTool_IsTemplateArgumentDependentType(type)
+ )
+ {
+ expr = argumentpromotion(expr, type, qual, 1);
+ } else {
+ element = CPrep_CurStreamElement();
+ if (element && element->tokenfile) {
+ templdepexpr = CExpr_NewTemplDepENode(TDE_SOURCEREF);
+ templdepexpr->data.templdep.u.sourceref.expr = expr;
+ templdepexpr->data.templdep.u.sourceref.token = galloc(sizeof(TStreamElement));
+ *templdepexpr->data.templdep.u.sourceref.token = *element;
+ expr = templdepexpr;
+ }
+ }
+
+ return CInline_CopyExpression(expr, CopyMode1);
+}
+
+static FuncArg *parameter_list(DeclInfo *declinfo) {
+ Boolean flag26;
+ FuncArg *args;
+ FuncArg *arg;
+ DeclInfo my_di;
+ Boolean isArray;
+
+ args = NULL;
+ flag26 = 1;
+
+ while (1) {
+ if (tk == TK_ELLIPSIS) {
+ if (flag26) {
+ if (!copts.cplusplus && copts.ANSI_strict)
+ CError_Warning(CErrorStr127);
+ args = &elipsis;
+ } else {
+ CFunc_AppendArg(&args, &elipsis);
+ }
+
+ tk = lex();
+ return args;
+ }
+
+ memclrw(&my_di, sizeof(my_di));
+ CParser_GetDeclSpecs(&my_di, 0);
+ if (my_di.x48)
+ CError_Error(CErrorStr127);
+
+ if (
+ my_di.storageclass &&
+ my_di.storageclass != TK_REGISTER &&
+ (!copts.cplusplus || my_di.storageclass != TK_AUTO)
+ )
+ {
+ CError_Error(CErrorStr127);
+ my_di.storageclass = 0;
+ }
+
+ my_di.name = NULL;
+
+ scandeclarator(&my_di);
+
+ if (flag26) {
+ flag26 = 0;
+ if (my_di.thetype == &stvoid) {
+ if (my_di.storageclass || my_di.qual || my_di.name)
+ CError_Error(CErrorStr127);
+ return NULL;
+ }
+ }
+
+ isArray = IS_TYPE_ARRAY(my_di.thetype);
+ adjustargumenttype(&my_di);
+
+ if (my_di.name) {
+ if (args && CFunc_IsInArgList(args, my_di.name))
+ CError_Error(CErrorStr122, my_di.name->name);
+ } else {
+ my_di.name = no_name_node;
+ }
+
+ if (my_di.thetype == &stvoid)
+ CError_Error(CErrorStr126);
+
+ arg = CParser_NewFuncArg();
+ arg->name = my_di.name;
+ arg->type = my_di.thetype;
+ arg->qual = my_di.qual;
+ arg->sclass = my_di.storageclass;
+ arg->is_array = isArray;
+ CFunc_AppendArg(&args, arg);
+
+ if (copts.cplusplus && tk == '=') {
+ tk = lex();
+ arg->dexpr = CFunc_DefaultArg(arg->type, arg->qual, args);
+ }
+
+ if (tk != ',') {
+ if (tk != TK_ELLIPSIS || !copts.cplusplus)
+ return args;
+ } else {
+ tk = lex();
+ }
+ }
+}
+
+Boolean CFunc_ParseFakeArgList(Boolean flag) {
+ DeclInfo di;
+
+ if (tk == TK_ELLIPSIS)
+ return 1;
+
+ do {
+ memclrw(&di, sizeof(di));
+ CParser_GetDeclSpecs(&di, 0);
+
+ if (di.x48)
+ return 0;
+
+ scandeclarator(&di);
+
+ if (tk == '=') {
+ tk = lex();
+ assignment_expression();
+ }
+
+ switch (tk) {
+ case TK_ELLIPSIS:
+ return 1;
+ case ',':
+ if (!flag)
+ tk = lex();
+ else
+ return 1;
+ break;
+ default:
+ return 0;
+ }
+ } while (tk != TK_ELLIPSIS);
+
+ return 1;
+}
+
+FuncArg *parameter_type_list(DeclInfo *declinfo) {
+ FuncArg *args;
+ NameSpace *nspace;
+ Boolean save_in_func_arglist;
+
+ declinfo->x44 = 0;
+ declinfo->x45 = 0;
+ declinfo->x1C = NULL;
+
+ if (tk == TK_ELLIPSIS || isdeclaration(0, 0, 0, 0)) {
+ if (!copts.cplusplus) {
+ nspace = CScope_NewListNameSpace(NULL, 0);
+ nspace->parent = cscope_current;
+ cscope_current = nspace;
+
+ save_in_func_arglist = in_func_arglist;
+ in_func_arglist = 1;
+ args = parameter_list(declinfo);
+ in_func_arglist = save_in_func_arglist;
+
+ cscope_current = nspace->parent;
+
+ if (!CScope_IsEmptyNameSpace(nspace))
+ declinfo->x1C = nspace;
+ } else {
+ args = parameter_list(declinfo);
+ }
+ } else if (copts.cplusplus) {
+ args = NULL;
+ if (tk != ')')
+ CError_Error(CErrorStr127);
+ } else {
+ identifier_list(declinfo);
+ args = &oldstyle;
+ }
+
+ return args;
+}
+
+CLabel *findlabel(void) {
+ CLabel *scan;
+
+ for (scan = Labels; scan; scan = scan->next) {
+ if (tkidentifier == scan->name)
+ return scan;
+ }
+
+ return NULL;
+}
+
+CLabel *newlabel(void) {
+ CLabel *label = lalloc(sizeof(CLabel));
+ memclrw(label, sizeof(CLabel));
+
+ label->name = label->uniquename = CParser_GetUniqueName();
+ return label;
+}
+
+Statement *CFunc_AppendStatement(StatementType sttype) {
+ Statement *stmt = lalloc(sizeof(Statement));
+
+ stmt->next = NULL;
+ stmt->type = sttype;
+ stmt->value = curstmtvalue;
+ stmt->flags = 0;
+ stmt->sourceoffset = sourceoffset;
+ stmt->sourcefilepath = sourcefilepath;
+ stmt->dobjstack = cexcept_dobjstack;
+
+ curstmt->next = stmt;
+ curstmt = stmt;
+ return stmt;
+}
+
+Statement *CFunc_InsertStatement(StatementType sttype, Statement *after) {
+ Statement *stmt = lalloc(sizeof(Statement));
+
+ stmt->next = after->next;
+ after->next = stmt;
+ stmt->type = sttype;
+ stmt->value = after->value;
+ stmt->flags = 0;
+ stmt->sourceoffset = after->sourceoffset;
+ stmt->sourcefilepath = after->sourcefilepath;
+ stmt->dobjstack = after->dobjstack;
+
+ return stmt;
+}
+
+Statement *CFunc_InsertBeforeStatement(StatementType sttype, Statement *before) {
+ Statement *stmt = lalloc(sizeof(Statement));
+
+ *stmt = *before;
+ before->next = stmt;
+ before->type = sttype;
+ before->flags = 0;
+
+ return before;
+}
+
+void CheckCLabels(void) {
+ CLabel *scan;
+
+ for (scan = Labels; scan; scan = scan->next) {
+ if (!scan->stmt)
+ CError_Error(CErrorStr159, scan->name->name);
+ }
+}
+
+Object *create_temp_object(Type *type) {
+ Object *object = CParser_NewLocalDataObject(NULL, 1);
+ object->name = CParser_GetUniqueName();
+ object->type = type;
+ CFunc_SetupLocalVarInfo(object);
+ return object;
+}
+
+ENode *create_temp_node(Type *type) {
+ ENode *node;
+
+ if (cinit_tempnodefunc)
+ return cinit_tempnodefunc(type, 0);
+
+ node = CExpr_NewETEMPNode(type, 0);
+ if (IS_TYPE_CLASS(type) && CClass_Destructor(TYPE_CLASS(type)))
+ node->data.temp.needs_dtor = 1;
+ return node;
+}
+
+ENode *create_temp_node2(Type *type) {
+ ENode *node;
+
+ if (cinit_tempnodefunc)
+ return cinit_tempnodefunc(type, 1);
+
+ node = CExpr_NewETEMPNode(type, 0);
+ node->data.temp.needs_dtor = 1;
+ return node;
+}
+
+static ENode *CFunc_DestroyReverse(ENode *expr, DtorTemp *list) {
+ expr = makediadicnode(expr, CABI_DestroyObject(list->dtor, create_objectrefnode(list->object), CABIDestroy1, 1, 0), ECOMMA);
+ expr->rtype = &stvoid;
+ if (list->next)
+ expr = CFunc_DestroyReverse(expr, list->next);
+ return expr;
+}
+
+static ENode *CFunc_TempTransDestroy(ENode *expr, DtorTemp *list, Boolean flag) {
+ Object *tempobj;
+
+ if (flag) {
+ CError_ASSERT(738, !(IS_TYPE_CLASS(expr->rtype) && CClass_Destructor(TYPE_CLASS(expr->rtype))));
+ tempobj = create_temp_object(expr->rtype);
+ expr = makediadicnode(create_objectnode(tempobj), expr, EASS);
+ }
+
+ expr = CFunc_DestroyReverse(expr, list);
+
+ if (flag) {
+ expr = makediadicnode(expr, create_objectnode(tempobj), ECOMMA);
+ expr->rtype = tempobj->type;
+ }
+
+ return expr;
+}
+
+void CFunc_WarnUnused(void) {
+ if (copts.warn_unusedvar) {
+ ObjectList *list;
+ for (list = locals; list; list = list->next) {
+ if (
+ !(list->object->flags & OBJECT_FLAGS_UNUSED) &&
+ !IsTempName(list->object->name) &&
+ !(list->object->qual & Q_10000)
+ )
+ {
+ CError_SetErrorToken(&list->object->u.var.info->deftoken);
+ CError_Warning(CErrorStr182, &list->object->name->name);
+ }
+ }
+ }
+
+ if (copts.warn_unusedarg) {
+ ObjectList *list;
+ for (list = arguments; list; list = list->next) {
+ if (
+ !(list->object->flags & OBJECT_FLAGS_UNUSED) &&
+ !IsTempName(list->object->name) &&
+ list->object->name != this_name_node &&
+ list->object->name != self_name_node
+ )
+ {
+ CError_SetErrorToken(&symdecltoken);
+ CError_Warning(CErrorStr182, &list->object->name->name);
+ }
+ }
+ }
+}
+
+void CFunc_CodeCleanup(Statement *stmt) {
+ if (cscope_currentclass && cscope_currentclass->sominfo)
+ CSOM_InitSOMSelf(cscope_currentclass, stmt);
+
+ CFunc_WarnUnused();
+ CExcept_ExceptionTansform(stmt);
+}
+
+static Boolean DestructorNeeded(ExceptionAction *ea, ExceptionAction *end) {
+ while (ea) {
+ if (CExcept_ActionNeedsDestruction(ea))
+ return 1;
+ if (ea == end)
+ break;
+ ea = ea->prev;
+ }
+
+ return 0;
+}
+
+static Statement *DestructLocals(Statement *stmt, ExceptionAction *ea, ExceptionAction *end) {
+ while (ea) {
+ stmt = CExcept_ActionCleanup(ea, stmt);
+ if (ea == end)
+ break;
+ ea = ea->prev;
+ }
+
+ return stmt;
+}
+
+static Boolean NeedsDestruction(Statement *stmt1, Statement *stmt2) {
+ ExceptionAction *ea2;
+ ExceptionAction *ea1;
+ ExceptionAction *scan;
+
+ ea1 = stmt1->dobjstack;
+ ea2 = stmt2->dobjstack;
+
+ for (scan = ea2; scan; scan = scan->prev) {
+ if (scan == ea1)
+ return 0;
+ }
+
+ while (ea1 && ea1 != ea2) {
+ if (CExcept_ActionNeedsDestruction(ea1))
+ return 1;
+ ea1 = ea1->prev;
+ }
+
+ return 0;
+}
+
+static ExceptionAction *FindLastNonCommonStackObj(Statement *stmt1, Statement *stmt2) {
+ ExceptionAction *ea1;
+ ExceptionAction *ea2;
+
+ for (ea2 = stmt2->dobjstack; ea2; ea2 = ea2->prev) {
+ for (ea1 = stmt1->dobjstack; ea1; ea1 = ea1->prev) {
+ if (ea1->prev == ea2)
+ return ea1;
+ }
+ }
+
+ return NULL;
+}
+
+static void DestructorReturnTransform(Statement *stmt1, Statement *stmt2) {
+ Statement *stmt;
+ Object *tempobj;
+
+ if (stmt1->dobjstack != stmt2->dobjstack && NeedsDestruction(stmt1, stmt2))
+ stmt1 = DestructLocals(stmt1, stmt1->dobjstack, FindLastNonCommonStackObj(stmt1, stmt2));
+
+ if (DestructorNeeded(stmt2->dobjstack, NULL)) {
+ if (CMach_GetFunctionResultClass(TYPE_FUNC(cscope_currentfunc->type)) != 1) {
+ tempobj = create_temp_object(stmt2->expr->rtype);
+ stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt1);
+ stmt->expr = makediadicnode(create_objectnode(tempobj), stmt2->expr, EASS);
+ stmt->sourceoffset = stmt2->sourceoffset;
+ stmt->sourcefilepath = stmt2->sourcefilepath;
+ DestructLocals(stmt, stmt2->dobjstack, NULL);
+ stmt2->expr = create_objectnode(tempobj);
+ } else {
+ stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt1);
+ stmt->expr = stmt2->expr;
+ stmt->sourceoffset = stmt2->sourceoffset;
+ stmt->sourcefilepath = stmt2->sourcefilepath;
+ DestructLocals(stmt, stmt2->dobjstack, NULL);
+ stmt2->expr = nullnode();
+ }
+ }
+}
+
+static Statement *DestructorIfTransform(Statement *stmt) {
+ CLabel *label;
+ Statement *newStmt;
+
+ if (stmt->type == ST_IFGOTO)
+ stmt->type = ST_IFNGOTO;
+ else
+ stmt->type = ST_IFGOTO;
+
+ label = newlabel();
+ newStmt = DestructLocals(stmt, stmt->dobjstack, FindLastNonCommonStackObj(stmt, stmt->label->stmt));
+ newStmt = CFunc_InsertStatement(ST_GOTO, newStmt);
+ newStmt->label = stmt->label;
+ newStmt = CFunc_InsertStatement(ST_LABEL, newStmt);
+ newStmt->label = label;
+ label->stmt = newStmt;
+ stmt->label = label;
+ newStmt->dobjstack = stmt->dobjstack;
+ return newStmt;
+}
+
+static Boolean IsSubStack(ExceptionAction *exc1, ExceptionAction *exc2) {
+ if (!exc1)
+ return 1;
+
+ while (exc2) {
+ if (exc2 == exc1)
+ return 1;
+ exc2 = exc2->prev;
+ }
+
+ return 0;
+}
+
+static void CFunc_CheckInitSkip(Statement *stmt, ExceptionAction *exc) {
+ if (stmt->dobjstack != exc && !IsSubStack(exc, stmt->dobjstack)) {
+ while (exc) {
+ if (CExcept_ActionNeedsDestruction(exc) && exc->type != EAT_ACTIVECATCHBLOCK) {
+ CError_Warning(CErrorStr211);
+ break;
+ }
+ exc = exc->prev;
+ }
+ }
+}
+
+void CFunc_DestructorCleanup(Statement *stmt) {
+ Statement *scan;
+ Statement *next;
+ SwitchCase *swcase;
+
+ if (copts.cplusplus) {
+ for (scan = stmt; scan; scan = scan->next) {
+ switch (scan->type) {
+ case ST_NOP:
+ case ST_LABEL:
+ case ST_EXPRESSION:
+ case ST_RETURN:
+ case ST_BEGINCATCH:
+ case ST_ENDCATCH:
+ case ST_ENDCATCHDTOR:
+ case ST_GOTOEXPR:
+ case ST_ASM:
+ break;
+ case ST_SWITCH:
+ CFunc_CheckInitSkip(scan, ((SwitchInfo *) scan->label)->defaultlabel->stmt->dobjstack);
+ for (swcase = ((SwitchInfo *) scan->label)->cases; swcase; swcase = swcase->next) {
+ CFunc_CheckInitSkip(scan, swcase->label->stmt->dobjstack);
+ }
+ break;
+ case ST_GOTO:
+ case ST_IFGOTO:
+ case ST_IFNGOTO:
+ CFunc_CheckInitSkip(scan, scan->label->stmt->dobjstack);
+ break;
+ default:
+ CError_FATAL(1045);
+ }
+ }
+
+ if (cexcept_hasdobjects) {
+ while (1) {
+ next = stmt->next;
+ if (!next) {
+ if (stmt->type != ST_RETURN && stmt->dobjstack)
+ DestructLocals(stmt, stmt->dobjstack, NULL);
+ return;
+ }
+
+ switch (next->type) {
+ case ST_GOTO:
+ if (
+ stmt->dobjstack != next->label->stmt->dobjstack &&
+ NeedsDestruction(stmt, next->label->stmt)
+ )
+ {
+ DestructLocals(stmt, stmt->dobjstack, FindLastNonCommonStackObj(stmt, next->label->stmt));
+ }
+ stmt = next;
+ continue;
+
+ case ST_RETURN:
+ if (next->expr && DestructorNeeded(stmt->dobjstack, NULL)) {
+ DestructorReturnTransform(stmt, next);
+ } else if (stmt->dobjstack) {
+ DestructLocals(stmt, stmt->dobjstack, NULL);
+ }
+ stmt = next;
+ continue;
+ }
+
+ switch (stmt->type) {
+ case ST_GOTO:
+ case ST_SWITCH:
+ case ST_RETURN:
+ case ST_GOTOEXPR:
+ break;
+ case ST_NOP:
+ case ST_LABEL:
+ case ST_EXPRESSION:
+ case ST_IFGOTO:
+ case ST_IFNGOTO:
+ case ST_BEGINCATCH:
+ case ST_ENDCATCH:
+ case ST_ENDCATCHDTOR:
+ case ST_ASM:
+ if (
+ stmt->dobjstack != next->dobjstack &&
+ NeedsDestruction(stmt, next)
+ )
+ {
+ DestructLocals(stmt, stmt->dobjstack, FindLastNonCommonStackObj(stmt, next));
+ }
+ break;
+ default:
+ CError_FATAL(1109);
+ }
+
+ switch (next->type) {
+ case ST_NOP:
+ case ST_LABEL:
+ case ST_EXPRESSION:
+ case ST_SWITCH:
+ case ST_BEGINCATCH:
+ case ST_ENDCATCH:
+ case ST_ENDCATCHDTOR:
+ case ST_ASM:
+ stmt = next;
+ continue;
+
+ case ST_IFGOTO:
+ case ST_IFNGOTO:
+ if (
+ next->dobjstack != next->label->stmt->dobjstack &&
+ NeedsDestruction(next, next->label->stmt)
+ )
+ {
+ stmt = DestructorIfTransform(next);
+ } else {
+ stmt = next;
+ }
+ break;
+
+ default:
+ CError_FATAL(1138);
+ }
+ }
+ }
+ }
+}
+
+static void scancase(DeclThing *thing) {
+ SwitchCase *swcase;
+ Statement *stmt;
+ CInt64 min;
+ CInt64 max;
+
+ if (!thing->switchinfo) {
+ CError_Error(CErrorStr169);
+ return;
+ }
+
+ tk = lex();
+ min = CExpr_IntConstConvert(thing->switchinfo->x8, thing->switchinfo->x8, CExpr_IntegralConstExpr());
+ if (!copts.ANSI_strict && tk == TK_ELLIPSIS) {
+ tk = lex();
+ max = CExpr_IntConstConvert(thing->switchinfo->x8, thing->switchinfo->x8, CExpr_IntegralConstExpr());
+ if (CInt64_Greater(min, max))
+ CError_Error(CErrorStr366);
+ if (thing->switchinfo->x8->size == stsignedlonglong.size)
+ CError_Error(CErrorStr368);
+ } else {
+ max = min;
+ }
+
+ for (swcase = thing->switchinfo->cases; swcase; swcase = swcase->next) {
+ if (CInt64_GreaterEqual(swcase->min, min) && CInt64_LessEqual(swcase->min, max))
+ CError_Error(CErrorStr172);
+ if (CInt64_GreaterEqual(swcase->max, min) && CInt64_LessEqual(swcase->max, max))
+ CError_Error(CErrorStr172);
+ if (CInt64_Less(swcase->min, min) && CInt64_Greater(swcase->max, max))
+ CError_Error(CErrorStr172);
+ }
+
+ stmt = CFunc_AppendStatement(ST_LABEL);
+ stmt->label = newlabel();
+ stmt->label->stmt = stmt;
+
+ swcase = lalloc(sizeof(SwitchCase));
+ swcase->min = min;
+ swcase->label = stmt->label;
+ swcase->next = thing->switchinfo->cases;
+ thing->switchinfo->cases = swcase;
+ swcase->max = max;
+
+ if (tk != ':')
+ CError_ErrorSkip(CErrorStr170);
+ else
+ tk = lex();
+
+ statement(thing);
+}
+
+static void CFunc_NameLocalStaticDataObject(Object *obj, char *str) {
+ char buf[64];
+ HashNameNode *name;
+
+ if (!(cscope_currentfunc && (cscope_currentfunc->qual & Q_INLINE)) || CParser_HasInternalLinkage(cscope_currentfunc)) {
+ obj->name = CParser_AppendUniqueName(str);
+ } else {
+ sprintf(buf, "$localstatic%ld$", cfunc_staticvarcount++);
+ name = CMangler_GetLinkName(cscope_currentfunc);
+ name = CParser_NameConcat(buf, name->name);
+ name = CParser_NameConcat(str, name->name);
+ obj->name = name;
+ obj->qual |= Q_20000;
+ obj->sclass = 0;
+ }
+}
+
+static void sinit_insert_expr(ENode *expr) {
+ Statement *stmt;
+
+ if (!sinit_first_object) {
+ sinit_first_object = CParser_NewCompilerDefDataObject();
+ sinit_first_object->type = TYPE(&stsignedchar);
+ sinit_first_object->sclass = TK_STATIC;
+ CFunc_NameLocalStaticDataObject(sinit_first_object, "init");
+ CInit_DeclareData(sinit_first_object, NULL, NULL, sinit_first_object->type->size);
+
+ sinit_label = newlabel();
+ stmt = CFunc_AppendStatement(ST_IFGOTO);
+ stmt->expr = create_objectnode(sinit_first_object);
+ stmt->label = sinit_label;
+ }
+
+ stmt = CFunc_AppendStatement(ST_EXPRESSION);
+ stmt->expr = expr;
+}
+
+static void ainit_insert_expr(ENode *expr) {
+ Statement *stmt;
+
+ if (ainit_only_one) {
+ if (ainit_expr) {
+ stmt = CFunc_AppendStatement(ST_EXPRESSION);
+ stmt->expr = ainit_expr;
+ }
+ ainit_expr = expr;
+ } else {
+ stmt = CFunc_AppendStatement(ST_EXPRESSION);
+ stmt->expr = expr;
+ }
+}
+
+static ENode *ainit_register_object(Type *type, Object *local, SInt32 offset, Boolean flag) {
+ return CExcept_RegisterDestructorObject(local, offset, CClass_Destructor(TYPE_CLASS(type)), flag);
+}
+
+static void CFunc_LocalDataDeclarator(DeclInfo *di, TStreamElement *deftoken, Boolean flag1, Boolean flag2) {
+ Object *object;
+ Object *aliasObject;
+ NameSpace *globalNS;
+ NameSpaceObjectList *nsol;
+ NameSpaceName *nsname;
+ Statement *stmt;
+
+ if (di->nspace)
+ CError_Error(CErrorStr121);
+
+ CDecl_CompleteType(di->thetype);
+
+ object = NULL;
+
+ if ((nsol = CScope_FindName(cscope_current, di->name))) {
+ switch (nsol->object->otype) {
+ case OT_OBJECT:
+ object = OBJECT(nsol->object);
+ break;
+ case OT_NAMESPACE:
+ CError_Error(CErrorStr321);
+ return;
+ case OT_ENUMCONST:
+ case OT_TYPE:
+ CError_Error(CErrorStr322);
+ break;
+ case OT_TYPETAG:
+ break;
+ default:
+ CError_FATAL(1344);
+ }
+ }
+
+ if (object)
+ CError_Error(CErrorStr333, object);
+
+ if (di->storageclass == TK_EXTERN) {
+ object = NULL;
+ globalNS = CScope_FindGlobalNS(cscope_current);
+ if ((nsol = CScope_FindName(globalNS, di->name))) {
+ switch (nsol->object->otype) {
+ case OT_OBJECT:
+ object = OBJECT(nsol->object);
+ break;
+ case OT_NAMESPACE:
+ CError_Error(CErrorStr321);
+ return;
+ case OT_ENUMCONST:
+ case OT_TYPE:
+ CError_Error(CErrorStr322);
+ break;
+ case OT_TYPETAG:
+ break;
+ default:
+ CError_FATAL(1381);
+ }
+ }
+
+ if (object) {
+ if (
+ !is_typesame(di->thetype, object->type) ||
+ (di->qual & (Q_CONST | Q_VOLATILE | Q_PASCAL | Q_20000 | Q_OVERLOAD | Q_ALIGNED_MASK)) != (object->qual & (Q_CONST | Q_VOLATILE | Q_PASCAL | Q_20000 | Q_OVERLOAD | Q_ALIGNED_MASK))
+ )
+ {
+ CError_Error(CErrorStr249, di->name->name, object->type, object->qual, di->thetype, di->qual);
+ }
+ } else {
+ object = CParser_NewGlobalDataObject(di);
+ object->nspace = globalNS;
+ }
+
+ CParser_NewAliasObject(object, 0);
+ return;
+ }
+
+ if (di->storageclass != TK_STATIC)
+ object = CParser_NewObject(di);
+ else
+ object = CParser_NewGlobalDataObject(di);
+
+ object->name = di->name;
+ object->type = di->thetype;
+ object->qual = di->qual;
+ object->sclass = di->storageclass;
+
+ switch (di->storageclass) {
+ case TK_STATIC:
+ if (flag1) {
+ CError_Error(CErrorStr177);
+ return;
+ }
+ if (flag2)
+ CError_Error(CErrorStr174);
+
+ if (CanCreateObject(di->thetype)) {
+ CError_QualifierCheck(di->qual & ~(Q_CONST | Q_VOLATILE | Q_PASCAL | Q_20000 | Q_OVERLOAD | Q_ALIGNED_MASK));
+ CParser_NewAliasObject(object, 0);
+ object->nspace = cscope_root;
+ object->datatype = DDATA;
+ CFunc_NameLocalStaticDataObject(object, object->name->name);
+
+ if (copts.cplusplus) {
+ sinit_first_object = NULL;
+ CInit_InitializeStaticData(object, sinit_insert_expr);
+ if (sinit_first_object) {
+ stmt = CFunc_AppendStatement(ST_EXPRESSION);
+ stmt->expr = makediadicnode(
+ create_objectnode(sinit_first_object),
+ intconstnode(TYPE(&stsignedchar), 1),
+ EASS);
+ stmt = CFunc_AppendStatement(ST_LABEL);
+ stmt->label = sinit_label;
+ sinit_label->stmt = stmt;
+ }
+ } else {
+ CInit_InitializeData(object);
+ }
+ }
+ break;
+
+ case 0:
+ case TK_AUTO:
+ case TK_REGISTER:
+ if (CanCreateObject(di->thetype)) {
+ CError_QualifierCheck(di->qual & ~(Q_CONST | Q_VOLATILE | Q_PASCAL | Q_ALIGNED_MASK));
+ object->datatype = DLOCAL;
+ CFunc_SetupLocalVarInfo(object);
+
+ object->u.var.info->deftoken = *deftoken;
+ if (object->sclass == TK_REGISTER && flag1)
+ object->u.var.info->usage = 100;
+
+ CScope_AddObject(cscope_current, object->name, OBJ_BASE(object));
+
+ if (!flag1) {
+ if (IS_TYPE_SOM_CLASS(di->thetype)) {
+ CSOM_InitAutoClass(object);
+ } else {
+ CInit_InitializeAutoData(object, ainit_insert_expr, ainit_register_object);
+ if (object->type != di->thetype && (IS_TYPE_STRUCT(object->type) || IS_TYPE_CLASS(object->type))) {
+ CError_ASSERT(1478, !cscope_current->is_hash);
+ CError_ASSERT(1479, nsname = CScope_FindNameSpaceName(cscope_current, object->name));
+ CError_ASSERT(1480, nsname->first.object == OBJ_BASE(object));
+ CError_ASSERT(1481, !nsname->first.next);
+ nsname->name = CParser_AppendUniqueName(object->name->name);
+
+ aliasObject = CParser_NewAliasObject(object, 0);
+ aliasObject->type = di->thetype;
+ }
+ }
+ }
+
+ if (object->datatype == DLOCAL) {
+ ObjectList *list = lalloc(sizeof(ObjectList));
+ list->object = object;
+ list->next = locals;
+ locals = list;
+ }
+
+ IsCompleteType(di->thetype);
+ }
+ break;
+
+ default:
+ CError_FATAL(1504);
+ }
+}
+
+static ENode *CFunc_ParseLocalDeclarationList(Boolean flag1, Boolean flag2, Boolean flag3, Boolean flag4) {
+ Type *type;
+ UInt32 qual;
+ DeclInfo di;
+ TStreamElement deftoken;
+
+ ainit_expr = NULL;
+ ainit_only_one = flag2;
+
+ while (flag2 || isdeclaration(copts.cplusplus, 0, 0, 0)) {
+ CPrep_GetFileOffsetInfo2(&cparser_fileoffset, &sourceoffset, &sourcefilepath);
+
+ memclrw(&di, sizeof(di));
+ di.x4E = cfunc_is_extern_c;
+ CParser_GetDeclSpecs(&di, 0);
+
+ if (IS_TYPE_TEMPLATE(di.thetype)) {
+ CError_Error(CErrorStr146);
+ di.thetype = TYPE(&stsignedint);
+ }
+
+ type = di.thetype;
+ qual = di.qual;
+
+ if (tk != ';') {
+ while (1) {
+ deftoken = *CPrep_CurStreamElement();
+ di.name = NULL;
+ scandeclarator(&di);
+
+ if (di.name) {
+ if (di.storageclass != TK_TYPEDEF) {
+ if (IS_TYPE_FUNC(di.thetype)) {
+ if (!CDecl_FunctionDeclarator(&di, CScope_FindGlobalNS(cscope_current), 0, 0))
+ break;
+ } else {
+ CFunc_LocalDataDeclarator(&di, &deftoken, flag1, flag2);
+ }
+ } else {
+ CDecl_TypedefDeclarator(&di);
+ }
+ } else {
+ CError_Error(CErrorStr134);
+ }
+
+ if (tk == ';')
+ break;
+
+ if (tk != ',') {
+ if (!flag2)
+ CError_Error(CErrorStr123);
+ break;
+ }
+
+ di.nspace = NULL;
+ di.thetype = type;
+ di.qual = qual;
+ tk = lex();
+ }
+ } else {
+ CParser_CheckAnonymousUnion(&di, 1);
+ }
+
+ if (flag2)
+ break;
+ if (flag4)
+ break;
+ tk = lex();
+ }
+
+ if (flag2) {
+ if (!ainit_expr) {
+ if (!flag3) {
+ CError_Error(CErrorStr141);
+ ainit_expr = nullnode();
+ }
+ } else {
+ ainit_expr = checkreference(ainit_expr);
+ }
+ }
+
+ return ainit_expr;
+}
+
+static void makeifstatement(ENode *expr, CLabel *label1, CLabel *label2, Boolean flag1, Boolean flag2) {
+ Statement *stmt;
+ CLabel *tmplabel;
+
+ if (!expr) {
+ if (flag1) {
+ stmt = CFunc_AppendStatement(ST_GOTO);
+ stmt->label = label1;
+ return;
+ }
+ return;
+ }
+
+ if (
+ ENODE_IS(expr, ETYPCON) &&
+ IS_TYPE_INT(expr->rtype) &&
+ IS_TYPE_INT(expr->data.monadic->rtype) &&
+ expr->rtype->size >= expr->data.monadic->rtype->size
+ )
+ expr = expr->data.monadic;
+
+ if (isnotzero(expr)) {
+ if (flag1) {
+ stmt = CFunc_AppendStatement(ST_GOTO);
+ stmt->label = label1;
+ return;
+ }
+ return;
+ }
+
+ if (iszero(expr)) {
+ if (!flag1) {
+ stmt = CFunc_AppendStatement(ST_GOTO);
+ stmt->label = label1;
+ return;
+ }
+ return;
+ }
+
+ if (ENODE_IS(expr, ELOGNOT)) {
+ makeifstatement(expr->data.monadic, label1, label2, !flag1, flag2);
+ return;
+ }
+
+ if (ENODE_IS(expr, ELOR)) {
+ tmplabel = newlabel();
+ if (flag1) {
+ makeifstatement(expr->data.diadic.left, label1, tmplabel, 1, flag2);
+ tmplabel->stmt = CFunc_AppendStatement(ST_LABEL);
+ tmplabel->stmt->label = tmplabel;
+ makeifstatement(expr->data.diadic.right, label1, label2, 1, flag2);
+ return;
+ } else {
+ makeifstatement(expr->data.diadic.left, label2, tmplabel, 1, flag2);
+ tmplabel->stmt = CFunc_AppendStatement(ST_LABEL);
+ tmplabel->stmt->label = tmplabel;
+ makeifstatement(expr->data.diadic.right, label1, label2, 0, flag2);
+ return;
+ }
+ }
+
+ if (ENODE_IS(expr, ELAND)) {
+ tmplabel = newlabel();
+ if (flag1) {
+ makeifstatement(expr->data.diadic.left, label2, tmplabel, 0, flag2);
+ tmplabel->stmt = CFunc_AppendStatement(ST_LABEL);
+ tmplabel->stmt->label = tmplabel;
+ makeifstatement(expr->data.diadic.right, label1, label2, 1, flag2);
+ return;
+ } else {
+ makeifstatement(expr->data.diadic.left, label1, tmplabel, 0, flag2);
+ tmplabel->stmt = CFunc_AppendStatement(ST_LABEL);
+ tmplabel->stmt->label = tmplabel;
+ makeifstatement(expr->data.diadic.right, label1, label2, 0, flag2);
+ return;
+ }
+ }
+
+ stmt = CFunc_AppendStatement(ST_IFGOTO);
+ stmt->label = label1;
+ stmt->expr = expr;
+ if (!flag1)
+ stmt->type = ST_IFNGOTO;
+ if (flag2)
+ stmt->flags |= StmtFlag_4;
+}
+
+static void CFunc_HasDtorTempCallBack(ENode *expr) {
+ if (expr->data.temp.needs_dtor || expr->data.temp.uniqueid)
+ cfunc_hasdtortemp = 1;
+}
+
+static void ifstatement(Boolean flag1, ENode *expr, CLabel *label, Boolean flag2) {
+ Statement *stmt;
+ CLabel *tmplabel;
+
+ if (expr && copts.cplusplus && copts.exceptions) {
+ cfunc_hasdtortemp = 0;
+ CExpr_SearchExprTree(expr, CFunc_HasDtorTempCallBack, 1, ETEMP);
+ if (cfunc_hasdtortemp) {
+ stmt = CFunc_AppendStatement(flag1 ? ST_IFGOTO : ST_IFNGOTO);
+ stmt->label = label;
+ stmt->expr = expr;
+ if (flag2)
+ stmt->flags |= StmtFlag_4;
+ return;
+ }
+ }
+
+ tmplabel = newlabel();
+ makeifstatement(expr, label, tmplabel, flag1, flag2);
+ tmplabel->stmt = CFunc_AppendStatement(ST_LABEL);
+ tmplabel->stmt->label = tmplabel;
+}
+
+Statement *CFunc_GenerateLoop(Statement *stmt, Type *type, ENode *lowerBound, ENode *upperBound, ENode *increment1, ENode *increment2, ENode *(*callback)(ENode *, ENode *)) {
+ ENode *var1;
+ ENode *var2;
+ CLabel *label;
+ ENode *ind;
+ ENode *ind2;
+ Statement *s;
+
+ var1 = CExpr_NewETEMPNode(type, 1);
+ ind = lalloc(sizeof(ENode));
+ *ind = *var1;
+ ind = makemonadicnode(ind, EINDIRECT);
+ ind->rtype = type;
+
+ // initialise var1 to lowerBound
+ if (stmt) {
+ stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+ s = stmt;
+ } else {
+ s = CFunc_AppendStatement(ST_EXPRESSION);
+ }
+ s->expr = makediadicnode(ind, lowerBound, EASS);
+
+ if (increment2) {
+ var2 = CExpr_NewETEMPNode(type, 1);
+ ind = lalloc(sizeof(ENode));
+ *ind = *var2;
+ ind = makemonadicnode(ind, EINDIRECT);
+ ind->rtype = type;
+
+ // initialise var2 to upperBound
+ if (stmt) {
+ stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+ s = stmt;
+ } else {
+ s = CFunc_AppendStatement(ST_EXPRESSION);
+ }
+ s->expr = makediadicnode(ind, upperBound, EASS);
+ }
+
+ // label for loop body
+ label = newlabel();
+ if (stmt) {
+ stmt = CFunc_InsertStatement(ST_LABEL, stmt);
+ s = stmt;
+ } else {
+ s = CFunc_AppendStatement(ST_LABEL);
+ }
+ s->label = label;
+ label->stmt = s;
+
+ if (callback) {
+ ind = lalloc(sizeof(ENode));
+ *ind = *var1;
+ ind = makemonadicnode(ind, EINDIRECT);
+ ind->rtype = type;
+
+ if (increment2) {
+ ind2 = lalloc(sizeof(ENode));
+ *ind2 = *var2;
+ ind2 = makemonadicnode(ind2, EINDIRECT);
+ ind2->rtype = type;
+ } else {
+ ind2 = NULL;
+ }
+
+ // generate a loop body
+ if ((ind = callback(ind, ind2))) {
+ if (stmt) {
+ stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+ s = stmt;
+ } else {
+ s = CFunc_AppendStatement(ST_EXPRESSION);
+ }
+ s->expr = ind;
+ }
+ }
+
+ if (increment1) {
+ ind = lalloc(sizeof(ENode));
+ *ind = *var1;
+ ind = makemonadicnode(ind, EINDIRECT);
+ ind->rtype = type;
+
+ // add increment1 to var1
+ if (stmt) {
+ stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+ s = stmt;
+ } else {
+ s = CFunc_AppendStatement(ST_EXPRESSION);
+ }
+ s->expr = makediadicnode(ind, increment1, EADDASS);
+
+ if (increment2) {
+ ind = lalloc(sizeof(ENode));
+ *ind = *var2;
+ ind = makemonadicnode(ind, EINDIRECT);
+ ind->rtype = type;
+
+ // add increment2 to var2
+ if (stmt) {
+ stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+ s = stmt;
+ } else {
+ s = CFunc_AppendStatement(ST_EXPRESSION);
+ }
+ s->expr = makediadicnode(ind, increment2, EADDASS);
+ }
+ }
+
+ ind = lalloc(sizeof(ENode));
+ *ind = *var1;
+ ind = makemonadicnode(ind, EINDIRECT);
+ ind->rtype = type;
+
+ // loop if var1 < upperBound
+ if (stmt) {
+ stmt = CFunc_InsertStatement(ST_IFGOTO, stmt);
+ s = stmt;
+ } else {
+ s = CFunc_AppendStatement(ST_IFGOTO);
+ }
+ s->expr = makediadicnode(ind, upperBound, ELESS);
+ s->expr->rtype = TYPE(&stbool);
+ s->label = label;
+ s->flags = StmtFlag_4;
+
+ return stmt;
+}
+
+static Boolean checklabel(void) {
+ HashNameNode *savename;
+ short savesize;
+ short token;
+
+ savename = tkidentifier;
+ savesize = tksize;
+ token = lookahead();
+ tkidentifier = savename;
+ tksize = savesize;
+
+ return token == ':';
+}
+
+static ENode *returnstatementadjust(ENode *expr, Type *type, UInt32 qual) {
+ Object *object;
+ ENode *expr2;
+ ENode *objexpr;
+ ObjectList *list;
+ ENodeList *exprlist;
+
+ for (list = arguments; list; list = list->next) {
+ if (list->object->name == temp_argument_name)
+ break;
+ }
+
+ CError_ASSERT(1907, list);
+
+ object = list->object;
+ if ((expr2 = CExpr_IsTempConstruction(expr, type, &objexpr)) && ENODE_IS(objexpr, ETEMP)) {
+ *objexpr = *create_objectnode(object);
+ return expr2;
+ }
+
+ if (IS_TYPE_CLASS(type)) {
+ expr2 = create_objectnode(object);
+ exprlist = lalloc(sizeof(ENodeList));
+ exprlist->next = NULL;
+ exprlist->node = expr;
+ return CExpr_ConstructObject(TYPE_CLASS(type), expr2, exprlist, 1, 1, 0, 1, 0);
+ }
+
+ expr2 = create_objectnode(object);
+ expr2 = makemonadicnode(expr2, EINDIRECT);
+ expr2->rtype = type;
+
+ return makediadicnode(expr2, CExpr_AssignmentPromotion(expr, type, qual, 1), EASS);
+}
+
+static void CFunc_AutoResultCheck(ENode *expr) {
+ while (1) {
+ while (ENODE_IS(expr, ECOMMA))
+ expr = expr->data.diadic.right;
+
+ switch (expr->type) {
+ case EOBJREF:
+ if (expr->data.objref->datatype != DLOCAL)
+ break;
+ case ETEMP:
+ CError_Warning(CErrorStr326);
+ break;
+ case EADD:
+ case ESUB:
+ CFunc_AutoResultCheck(expr->data.diadic.left);
+ expr = expr->data.diadic.right;
+ continue;
+ default:
+ break;
+ }
+ break;
+ }
+}
+
+static void statement(DeclThing *thing) {
+ Statement *stmt;
+ Statement *stmt2;
+ CLabel *label;
+ DeclBlock *block;
+ ENode *expr;
+ HashNameNode *name;
+ DeclThing subthing;
+
+ CPrep_GetFileOffsetInfo2(&cparser_fileoffset, &sourceoffset, &sourcefilepath);
+
+ switch (tk) {
+ case TK_RETURN:
+ tk = lex();
+ if (
+ (thing->thetype == &stvoid && !copts.cplusplus) ||
+ CClass_IsConstructor(cscope_currentfunc) ||
+ CClass_IsDestructor(cscope_currentfunc)
+ )
+ {
+ if (tk != ';') {
+ CError_Error(CErrorStr315);
+ expression();
+ }
+
+ stmt = CFunc_AppendStatement(ST_RETURN);
+ stmt->expr = NULL;
+ CError_ResetErrorSkip();
+ tk = lex();
+ return;
+ }
+
+ if (tk == ';') {
+ if (thing->thetype != &stvoid && (copts.pedantic || copts.cplusplus))
+ CError_Warning(CErrorStr184);
+
+ stmt = CFunc_AppendStatement(ST_RETURN);
+ stmt->expr = NULL;
+ CError_ResetErrorSkip();
+ tk = lex();
+ return;
+ }
+
+ if (copts.old_argmatch)
+ expr = expression();
+ else
+ expr = s_expression();
+
+ if (thing->thetype == &stvoid) {
+ if (expr->rtype != &stvoid)
+ CError_Error(CErrorStr315);
+
+ stmt = CFunc_AppendStatement(ST_EXPRESSION);
+ stmt->expr = expr;
+
+ stmt = CFunc_AppendStatement(ST_RETURN);
+ stmt->expr = NULL;
+ } else {
+ if (CMach_GetFunctionResultClass(TYPE_FUNC(cscope_currentfunc->type)) == 1)
+ expr = returnstatementadjust(expr, thing->thetype, thing->qual);
+ else
+ expr = CExpr_AssignmentPromotion(expr, thing->thetype, thing->qual, 1);
+
+ stmt = CFunc_AppendStatement(ST_RETURN);
+ stmt->expr = expr;
+
+ if (IS_TYPE_POINTER_ONLY(thing->thetype))
+ CFunc_AutoResultCheck(expr);
+ }
+
+ break;
+
+ case TK_CASE:
+ scancase(thing);
+ return;
+
+ case TK_DEFAULT:
+ if (!thing->switchinfo) {
+ CError_Error(CErrorStr169);
+ return;
+ }
+
+ if (lex() != ':')
+ CError_ErrorSkip(CErrorStr170);
+ else
+ tk = lex();
+
+ if (thing->switchinfo->defaultlabel)
+ CError_ErrorSkip(CErrorStr173);
+
+ stmt = CFunc_AppendStatement(ST_LABEL);
+ stmt->label = newlabel();
+ stmt->label->stmt = stmt;
+ thing->switchinfo->defaultlabel = stmt->label;
+ statement(thing);
+ return;
+
+ case TK_SWITCH:
+ if (lex() != '(')
+ CError_ErrorSkip(CErrorStr114);
+ else
+ tk = lex();
+
+ if (copts.cplusplus && !copts.ARM_scoping && isdeclaration(1, 0, 0, '=')) {
+ block = CFunc_NewDeclBlock();
+ expr = CFunc_ParseLocalDeclarationList(0, 1, 0, 0);
+ if (CScope_IsEmptyNameSpace(cscope_current)) {
+ CFunc_RestoreBlock(block);
+ block = NULL;
+ }
+ } else {
+ expr = expression();
+ block = NULL;
+ }
+
+ stmt = CFunc_AppendStatement(ST_SWITCH);
+ stmt->expr = CExpr_ConvertToIntegral(expr);
+
+ if (tk != ')')
+ CError_ErrorSkip(CErrorStr115);
+ else
+ tk = lex();
+
+ stmt->label = (CLabel *) lalloc(sizeof(SwitchInfo));
+ ((SwitchInfo *) stmt->label)->defaultlabel = NULL;
+ ((SwitchInfo *) stmt->label)->cases = NULL;
+ ((SwitchInfo *) stmt->label)->x8 = stmt->expr->rtype;
+
+ label = newlabel();
+ subthing = *thing;
+ subthing.loopBreak = label;
+ subthing.switchinfo = (SwitchInfo *) stmt->label;
+ CFunc_CompoundStatement(&subthing);
+
+ if (!subthing.switchinfo->defaultlabel)
+ subthing.switchinfo->defaultlabel = label;
+
+ if (!subthing.switchinfo->cases) {
+ stmt->type = ST_EXPRESSION;
+ stmt2 = lalloc(sizeof(Statement));
+ *stmt2 = *stmt;
+ stmt->next = stmt2;
+ stmt2->type = ST_GOTO;
+ stmt2->label = subthing.switchinfo->defaultlabel;
+ stmt2->dobjstack = cexcept_dobjstack;
+ }
+
+ stmt = CFunc_AppendStatement(ST_LABEL);
+ stmt->label = label;
+ label->stmt = stmt;
+
+ if (block)
+ CFunc_RestoreBlock(block);
+ return;
+
+ case TK_GOTO:
+ if ((tk = lex()) != TK_IDENTIFIER) {
+ if (tk == '*' && !copts.ANSI_strict) {
+ tk = lex();
+ stmt = CFunc_AppendStatement(ST_GOTOEXPR);
+ stmt->expr = expression();
+ if (!IS_TYPE_POINTER_ONLY(stmt->expr->rtype)) {
+ CError_Error(CErrorStr146);
+ stmt->expr = nullnode();
+ stmt->expr->rtype = TYPE(&void_ptr);
+ }
+ } else {
+ CError_Error(CErrorStr107);
+ return;
+ }
+ } else {
+ stmt = CFunc_AppendStatement(ST_GOTO);
+ if (!(stmt->label = findlabel())) {
+ stmt->label = newlabel();
+ stmt->label->next = Labels;
+ Labels = stmt->label;
+ stmt->label->name = tkidentifier;
+ }
+ tk = lex();
+ }
+ break;
+
+ case TK_BREAK:
+ if (thing->loopBreak) {
+ stmt = CFunc_AppendStatement(ST_GOTO);
+ stmt->label = thing->loopBreak;
+ } else {
+ CError_Error(CErrorStr169);
+ }
+ tk = lex();
+ break;
+
+ case TK_CONTINUE:
+ if (thing->loopContinue) {
+ stmt = CFunc_AppendStatement(ST_GOTO);
+ stmt->label = thing->loopContinue;
+ } else {
+ CError_Error(CErrorStr169);
+ }
+ tk = lex();
+ break;
+
+ case TK_FOR: {
+ CLabel *forLabel1;
+ CLabel *forLabel2;
+ CLabel *forLabel3;
+ ENode *forCond;
+ ENode *forInc;
+
+ if (lex() != '(')
+ CError_ErrorSkip(CErrorStr114);
+ else
+ tk = lex();
+
+ block = NULL;
+ if (tk != ';') {
+ if (!copts.cplusplus || !isdeclaration(1, 0, 0, 0)) {
+ expr = expression();
+ CExpr_CheckUnusedExpression(expr);
+ } else {
+ if (!copts.ARM_scoping)
+ block = CFunc_NewDeclBlock();
+ expr = CFunc_ParseLocalDeclarationList(0, 1, 1, 0);
+ if (block && CScope_IsEmptyNameSpace(cscope_current)) {
+ CFunc_RestoreBlock(block);
+ block = NULL;
+ }
+ }
+
+ if (expr) {
+ stmt = CFunc_AppendStatement(ST_EXPRESSION);
+ stmt->expr = expr;
+ }
+
+ if (tk == ';')
+ CError_ResetErrorSkip();
+ else
+ CError_Error(CErrorStr123);
+ } else {
+ CError_ResetErrorSkip();
+ }
+
+ if ((tk = lex()) != ';') {
+ if (copts.cplusplus && !copts.ARM_scoping && isdeclaration(1, 0, 0, '=')) {
+ if (!block)
+ block = CFunc_NewDeclBlock();
+ expr = CFunc_ParseLocalDeclarationList(0, 1, 0, 0);
+ if (CScope_IsEmptyNameSpace(cscope_current)) {
+ CFunc_RestoreBlock(block);
+ block = NULL;
+ }
+ } else {
+ expr = expression();
+ CExpr_CheckUnwantedAssignment(expr);
+ }
+
+ forCond = CExpr_ConvertToCondition(expr);
+
+ if (tk == ';')
+ CError_ResetErrorSkip();
+ else
+ CError_Error(CErrorStr123);
+ } else {
+ CError_ResetErrorSkip();
+ forCond = NULL;
+ }
+
+ if ((tk = lex()) != ')') {
+ forInc = expression();
+ CExpr_CheckUnusedExpression(forInc);
+ if (tk == ')')
+ CError_ResetErrorSkip();
+ else
+ CError_Error(CErrorStr115);
+ } else {
+ CError_ResetErrorSkip();
+ forInc = NULL;
+ }
+
+ if (copts.warn_possunwant) {
+ spaceskip = 0;
+ if ((tk = lex()) == ';' && !spaceskip)
+ CError_Warning(CErrorStr206);
+ } else {
+ tk = lex();
+ }
+
+ if (forCond) {
+ stmt = CFunc_AppendStatement(ST_GOTO);
+ label = newlabel();
+ stmt->label = label;
+ } else {
+ label = newlabel();
+ }
+
+ CFunc_LoopIncrement();
+
+ stmt = CFunc_AppendStatement(ST_LABEL);
+ forLabel1 = stmt->label = newlabel();
+ forLabel1->stmt = stmt;
+
+ forLabel2 = newlabel();
+ forLabel3 = newlabel();
+
+ subthing = *thing;
+ subthing.loopContinue = forLabel3;
+ subthing.loopBreak = forLabel2;
+
+ if (tk != '{') {
+ DeclBlock *b = CFunc_NewDeclBlock();
+ CFunc_CompoundStatement(&subthing);
+ CFunc_RestoreBlock(b);
+ } else {
+ CFunc_CompoundStatement(&subthing);
+ }
+
+ stmt = CFunc_AppendStatement(ST_LABEL);
+ stmt->label = forLabel3;
+ forLabel3->stmt = stmt;
+
+ if (forInc) {
+ stmt = CFunc_AppendStatement(ST_EXPRESSION);
+ stmt->expr = forInc;
+ }
+
+ stmt = CFunc_AppendStatement(ST_LABEL);
+ stmt->label = label;
+ label->stmt = stmt;
+
+ ifstatement(1, forCond, forLabel1, 1);
+ CFunc_LoopDecrement();
+
+ stmt = CFunc_AppendStatement(ST_LABEL);
+ stmt->label = forLabel2;
+ forLabel2->stmt = stmt;
+
+ if (block)
+ CFunc_RestoreBlock(block);
+
+ return;
+ }
+
+ case TK_DO: {
+ CLabel *label1;
+ CLabel *label2;
+ CLabel *label3;
+
+ CFunc_LoopIncrement();
+ stmt = CFunc_AppendStatement(ST_LABEL);
+ label1 = stmt->label = newlabel();
+ label1->stmt = stmt;
+
+ label2 = newlabel();
+ label3 = newlabel();
+
+ subthing = *thing;
+ subthing.loopContinue = label2;
+ subthing.loopBreak = label3;
+
+ tk = lex();
+ CFunc_CompoundStatement(&subthing);
+
+ stmt = CFunc_AppendStatement(ST_LABEL);
+ stmt->label = label2;
+ label2->stmt = stmt;
+
+ if (tk != TK_WHILE)
+ CError_Error(CErrorStr105);
+
+ if (lex() != '(')
+ CError_ErrorSkip(CErrorStr114);
+ else
+ tk = lex();
+
+ expr = CExpr_ConvertToCondition(expression());
+ CExpr_CheckUnwantedAssignment(expr);
+
+ if (tk != ')')
+ CError_ErrorSkip(CErrorStr115);
+ else
+ tk = lex();
+
+ ifstatement(1, expr, label1, 1);
+
+ CFunc_LoopDecrement();
+
+ stmt = CFunc_AppendStatement(ST_LABEL);
+ stmt->label = label3;
+ label3->stmt = stmt;
+ break;
+ }
+
+ case TK_WHILE: {
+ CLabel *label1;
+ CLabel *label2;
+ CLabel *label3;
+
+ if ((tk = lex()) != '(')
+ CError_ErrorSkip(CErrorStr114);
+ else
+ tk = lex();
+
+ if (copts.cplusplus && !copts.ARM_scoping && isdeclaration(1, 0, 0, '=')) {
+ block = CFunc_NewDeclBlock();
+ expr = CFunc_ParseLocalDeclarationList(0, 1, 0, 0);
+ if (CScope_IsEmptyNameSpace(cscope_current)) {
+ CFunc_RestoreBlock(block);
+ block = NULL;
+ }
+ } else {
+ expr = expression();
+ block = NULL;
+ CExpr_CheckUnwantedAssignment(expr);
+ }
+ expr = CExpr_ConvertToCondition(expr);
+
+ if (tk != ')') {
+ CError_ErrorSkip(CErrorStr115);
+ } else {
+ if (copts.warn_possunwant) {
+ spaceskip = 0;
+ if ((tk = lex()) == ';' && !spaceskip)
+ CError_Warning(CErrorStr206);
+ } else {
+ tk = lex();
+ }
+ }
+
+ stmt = CFunc_AppendStatement(ST_GOTO);
+ label1 = newlabel();
+ stmt->label = label1;
+
+ CFunc_LoopIncrement();
+
+ stmt = CFunc_AppendStatement(ST_LABEL);
+ label2 = stmt->label = newlabel();
+ label2->stmt = stmt;
+
+ label3 = newlabel();
+
+ subthing = *thing;
+ subthing.loopContinue = label1;
+ subthing.loopBreak = label3;
+
+ CFunc_CompoundStatement(&subthing);
+
+ stmt = CFunc_AppendStatement(ST_LABEL);
+ stmt->label = label1;
+ label1->stmt = stmt;
+
+ ifstatement(1, expr, label2, 1);
+
+ CFunc_LoopDecrement();
+
+ stmt = CFunc_AppendStatement(ST_LABEL);
+ stmt->label = label3;
+ label3->stmt = stmt;
+
+ if (block)
+ CFunc_RestoreBlock(block);
+ return;
+ }
+
+ case TK_IF: {
+ CLabel *label1;
+ if ((tk = lex()) != '(')
+ CError_ErrorSkip(CErrorStr114);
+ else
+ tk = lex();
+
+ if (copts.cplusplus && !copts.ARM_scoping && isdeclaration(1, 0, 0, '=')) {
+ block = CFunc_NewDeclBlock();
+ expr = CFunc_ParseLocalDeclarationList(0, 1, 0, 0);
+ if (CScope_IsEmptyNameSpace(cscope_current)) {
+ CFunc_RestoreBlock(block);
+ block = NULL;
+ }
+ } else {
+ expr = expression();
+ block = NULL;
+ CExpr_CheckUnwantedAssignment(expr);
+ }
+
+ expr = CExpr_ConvertToCondition(expr);
+
+ label1 = newlabel();
+ ifstatement(0, expr, label1, 0);
+
+ if (tk != ')') {
+ CError_ErrorSkip(CErrorStr115);
+ } else {
+ if (copts.warn_possunwant) {
+ spaceskip = 0;
+ if ((tk = lex()) == ';' && !spaceskip)
+ CError_Warning(CErrorStr206);
+ } else {
+ tk = lex();
+ }
+ }
+
+ CFunc_CompoundStatement(thing);
+
+ if (tk == TK_ELSE) {
+ if (copts.warn_possunwant) {
+ spaceskip = 0;
+ if ((tk = lex()) == ';' && !spaceskip)
+ CError_Warning(CErrorStr206);
+ } else {
+ tk = lex();
+ }
+
+ stmt = CFunc_AppendStatement(ST_GOTO);
+ label = stmt->label = newlabel();
+
+ stmt = CFunc_AppendStatement(ST_LABEL);
+ stmt->label = label1;
+ label1->stmt = stmt;
+
+ CFunc_CompoundStatement(thing);
+
+ label1 = label;
+ }
+
+ stmt = CFunc_AppendStatement(ST_LABEL);
+ stmt->label = label1;
+ label1->stmt = stmt;
+
+ if (block)
+ CFunc_RestoreBlock(block);
+
+ return;
+ }
+
+ case '{':
+ CFunc_CompoundStatement(thing);
+ return;
+
+ case TK_ASM:
+ if (copts.cplusplus || !copts.ANSI_strict) {
+ tk = lex();
+ volatileasm = 0;
+
+ if (tk == TK_VOLATILE || (tk == TK_IDENTIFIER && !strcmp(tkidentifier->name, "__volatile__"))) {
+ tk = lex();
+ volatileasm = 1;
+ }
+
+ if (tk == '(') {
+ InlineAsm_Assemble();
+ if (tk == ')') {
+ tk = lex();
+ break;
+ } else {
+ CError_Error(CErrorStr115);
+ return;
+ }
+ }
+
+ if (tk == '{') {
+ InlineAsm_Assemble();
+ if (tk != '}') {
+ CError_Error(CErrorStr130);
+ return;
+ }
+ if ((tk = lex()) == ';')
+ tk = lex();
+ CError_ResetErrorSkip();
+ return;
+ }
+
+ CError_Error(CErrorStr114);
+ } else {
+ CError_Error(CErrorStr121);
+ }
+ return;
+
+ case TK_TRY:
+ tk = lex();
+ CExcept_ScanTryBlock(thing, 0);
+ return;
+
+ case TK_USING:
+ if ((tk = lex()) == TK_NAMESPACE) {
+ tk = lex();
+ CScope_ParseUsingDirective(cscope_current);
+ } else {
+ CScope_ParseUsingDeclaration(cscope_current, 0, 0);
+ }
+ return;
+
+ case TK_NAMESPACE:
+ if ((tk = lex()) != TK_IDENTIFIER) {
+ CError_Error(CErrorStr107);
+ return;
+ }
+ name = tkidentifier;
+ if ((tk = lex()) != '=') {
+ CError_Error(CErrorStr121);
+ return;
+ }
+
+ CScope_ParseNameSpaceAlias(name);
+ break;
+
+ case ';':
+ break;
+
+ case TK_IDENTIFIER:
+ if (checklabel()) {
+ stmt = CFunc_AppendStatement(ST_LABEL);
+ if ((stmt->label = findlabel())) {
+ if (stmt->label->stmt)
+ CError_Error(CErrorStr171, tkidentifier->name);
+ } else {
+ stmt->label = newlabel();
+ stmt->label->next = Labels;
+ Labels = stmt->label;
+ stmt->label->name = tkidentifier;
+ }
+
+ stmt->label->stmt = stmt;
+ tk = lex();
+ tk = lex();
+ statement(thing);
+ return;
+ }
+ tk = TK_IDENTIFIER;
+
+ default:
+ if (copts.cplusplus && isdeclaration(1, 0, 0, 0)) {
+ CFunc_ParseLocalDeclarationList(0, 0, 0, 1);
+ tk = lex();
+ return;
+ }
+
+ stmt = CFunc_AppendStatement(ST_EXPRESSION);
+ stmt->expr = expression();
+ CExpr_CheckUnusedExpression(stmt->expr);
+ }
+
+ if (tk == ';') {
+ CPrep_TokenStreamFlush();
+ tk = lex();
+ CError_ResetErrorSkip();
+ } else {
+ CError_ErrorSkip(CErrorStr123);
+ }
+}
+
+void CFunc_CompoundStatement(DeclThing *thing) {
+ DeclBlock *block;
+
+ block = CFunc_NewDeclBlock();
+
+ if (tk == '{') {
+ tk = lex();
+ if (!copts.cplusplus && isdeclaration(0, 0, 0, 0))
+ CFunc_ParseLocalDeclarationList(0, 0, 0, 0);
+
+ while (tk != '}')
+ statement(thing);
+
+ CPrep_GetFileOffsetInfo2(&cparser_fileoffset, &sourceoffset, &sourcefilepath);
+ tk = lex();
+ } else {
+ statement(thing);
+ }
+
+ CFunc_RestoreBlock(block);
+}
+
+static void CFunc_InsertArgumentCopyConversion(Object *obj, Type *type1, Type *type2, Boolean flag) {
+ Object *newobj;
+ Statement *stmt;
+ ENode *expr;
+ NameSpaceObjectList *nsol;
+ ObjectList *list;
+
+ newobj = lalloc(sizeof(Object));
+ *newobj = *obj;
+ newobj->type = type2;
+
+ CFunc_SetupLocalVarInfo(newobj);
+
+ obj->name = CParser_GetUniqueName();
+ if (flag)
+ obj->type = CDecl_NewPointerType(type1);
+ else
+ obj->type = type1;
+
+ CError_ASSERT(2527, (nsol = CScope_FindName(cscope_current, newobj->name)) && nsol->object == OBJ_BASE(obj));
+ nsol->object = OBJ_BASE(newobj);
+
+ list = lalloc(sizeof(ObjectList));
+ list->object = newobj;
+ list->next = locals;
+ locals = list;
+
+ stmt = CFunc_AppendStatement(ST_EXPRESSION);
+ expr = create_objectnode(obj);
+ if (flag) {
+ expr->rtype = CDecl_NewPointerType(type1);
+ expr = makemonadicnode(expr, EINDIRECT);
+ }
+ expr->rtype = type1;
+
+ if (type1 != type2)
+ expr = promote(expr, type2);
+
+ stmt->expr = makediadicnode(create_objectnode(newobj), expr, EASS);
+}
+
+static void CFunc_AdjustOldStyleArgs(void) {
+ ObjectList *list;
+
+ for (list = arguments; list; list = list->next) {
+ if (IS_TYPE_FLOAT(list->object->type) && list->object->type->size < stdouble.size)
+ CFunc_InsertArgumentCopyConversion(list->object, TYPE(&stdouble), list->object->type, 0);
+ }
+}
+
+void CFunc_SetupNewFuncArgs(Object *func, FuncArg *args) {
+ Object *obj;
+ ObjectList *newlist;
+
+ arguments = NULL;
+
+ if (args != &elipsis && args != &oldstyle) {
+ newlist = NULL;
+
+ while (args && args != &elipsis) {
+ IsCompleteType(args->type);
+
+ obj = CParser_NewLocalDataObject(NULL, 0);
+ obj->name = !args->name ? no_name_node : args->name;
+ obj->type = args->type;
+ obj->qual = args->qual;
+ obj->sclass = args->sclass;
+
+ CFunc_SetupLocalVarInfo(obj);
+
+ if (IS_TYPE_CLASS(obj->type) && CClass_ReferenceArgument(TYPE_CLASS(obj->type))) {
+ obj->type = CDecl_NewPointerType(obj->type);
+ TPTR_QUAL(obj->type) = Q_REFERENCE | Q_RESTRICT;
+ }
+
+ if (obj->name == no_name_node && copts.ANSI_strict && !copts.cplusplus && !(func->qual & Q_80000))
+ CError_Error(CErrorStr127);
+
+ if (newlist) {
+ newlist->next = lalloc(sizeof(ObjectList));
+ newlist = newlist->next;
+ } else {
+ newlist = lalloc(sizeof(ObjectList));
+ arguments = newlist;
+ }
+
+ newlist->next = NULL;
+ newlist->object = obj;
+
+ args = args->next;
+ }
+ }
+}
+
+static ObjectList *CFunc_CopyObjectList(const FuncArg *args) {
+ Object *obj;
+ ObjectList *list;
+ ObjectList *last;
+
+ list = NULL;
+
+ while (args) {
+ if (list) {
+ last->next = lalloc(sizeof(ObjectList));
+ last = last->next;
+ } else {
+ last = lalloc(sizeof(ObjectList));
+ list = last;
+ }
+
+ obj = CParser_NewLocalDataObject(NULL, 0);
+ obj->name = args->name;
+ obj->type = args->type;
+ obj->qual = args->qual;
+ obj->sclass = args->sclass;
+ CFunc_SetupLocalVarInfo(obj);
+
+ last->object = obj;
+ last->next = NULL;
+
+ args = args->next;
+ }
+
+ return list;
+}
+
+static void SetupFunctionArguments(Object *func, DeclInfo *di, Statement *firstStmt) {
+ ObjectList *list;
+ Object *resultobj;
+ Object *obj;
+ Type *type;
+ DeclInfo my_di;
+
+ if (TYPE_FUNC(func->type)->args) {
+ if (di->x45) {
+ arguments = CFunc_CopyObjectList(di->x18);
+ while (1) {
+ if (tk == '{')
+ break;
+
+ memclrw(&my_di, sizeof(my_di));
+ CParser_GetDeclSpecs(&my_di, 0);
+
+ type = my_di.thetype;
+ if (my_di.storageclass && my_di.storageclass != TK_REGISTER)
+ CError_Error(CErrorStr127);
+
+ while (1) {
+ my_di.thetype = type;
+ my_di.name = NULL;
+ scandeclarator(&my_di);
+ if (!my_di.name) {
+ CError_Error(CErrorStr107);
+ break;
+ }
+
+ adjustargumenttype(&my_di);
+ IsCompleteType(my_di.thetype);
+
+ if ((obj = CFunc_IsInObjList(arguments, my_di.name))) {
+ if (obj->type)
+ CError_Error(CErrorStr333, obj);
+ obj->type = my_di.thetype;
+ obj->sclass = my_di.storageclass;
+ obj->qual = my_di.qual;
+ } else {
+ CError_Error(CErrorStr127);
+ }
+
+ if (tk != ',')
+ break;
+ tk = lex();
+ }
+
+ if (tk != ';')
+ CError_ErrorSkip(CErrorStr123);
+ else
+ tk = lex();
+ }
+
+ for (list = arguments; list; list = list->next) {
+ if (!list->object->type)
+ list->object->type = TYPE(&stsignedint);
+ }
+ } else {
+ CFunc_SetupNewFuncArgs(func, TYPE_FUNC(func->type)->args);
+ }
+ }
+
+ if (CMach_GetFunctionResultClass(TYPE_FUNC(func->type)) == 1) {
+ resultobj = CParser_NewLocalDataObject(NULL, 0);
+ resultobj->name = temp_argument_name;
+ resultobj->type = CDecl_NewPointerType(TYPE_FUNC(func->type)->functype);
+ CFunc_SetupLocalVarInfo(resultobj);
+
+ list = lalloc(sizeof(ObjectList));
+ list->object = resultobj;
+ if (CABI_GetStructResultArgumentIndex(TYPE_FUNC(func->type))) {
+ CError_ASSERT(2797, arguments);
+ list->next = arguments->next;
+ arguments->next = list;
+ } else {
+ list->next = arguments;
+ arguments = list;
+ }
+ }
+
+ for (list = arguments; list; list = list->next) {
+ NameSpaceObjectList *nsol = CScope_InsertName(cscope_current, list->object->name);
+ nsol->object = OBJ_BASE(list->object);
+ }
+}
+
+NameSpace *CFunc_FuncGenSetup(Statement *stmt, Object *func) {
+ NameSpace *nspace;
+ DeclBlock *block;
+
+ nspace = CScope_NewListNameSpace(NULL, 0);
+ nspace->parent = cscope_current;
+ cscope_current = nspace;
+
+ arguments = NULL;
+ locals = NULL;
+ Labels = NULL;
+
+ localcount = 0;
+ cfunc_staticvarcount = 0;
+
+ CExcept_Setup();
+
+ memclrw(stmt, sizeof(Statement));
+ curstmt = stmt;
+ stmt->type = ST_NOP;
+ curstmtvalue = 1;
+ stmt->value = 1;
+
+ blockcount = 0;
+ block = lalloc(sizeof(DeclBlock));
+ memclrw(block, sizeof(DeclBlock));
+ block->index = blockcount++;
+ block->parent_nspace = cscope_current;
+
+ firstblock = block;
+ currentblock = block;
+
+ return nspace;
+}
+
+CFuncSave *CFunc_GetGlobalCompilerState(void) {
+ CFuncSave *state;
+
+ if (!cscope_currentfunc && !cscope_currentclass && cscope_current == cscope_root)
+ return NULL;
+
+ locklheap();
+ state = lalloc(sizeof(CFuncSave));
+
+ CScope_SetNameSpaceScope(cscope_root, &state->scope);
+
+ state->arguments = arguments;
+ arguments = NULL;
+
+ state->locals = locals;
+ locals = NULL;
+
+ state->labels = Labels;
+ Labels = NULL;
+
+ state->curstmt = curstmt;
+ curstmt = NULL;
+
+ state->firstblock = firstblock;
+ firstblock = NULL;
+
+ state->currentblock = currentblock;
+ currentblock = NULL;
+
+ state->cexcept_dobjstack = cexcept_dobjstack;
+ cexcept_dobjstack = NULL;
+
+ state->sinit_label = sinit_label;
+ sinit_label = NULL;
+
+ state->ainit_expr = ainit_expr;
+ ainit_expr = NULL;
+
+ state->ctor_chain = ctor_chain;
+ ctor_chain = NULL;
+
+ state->cinit_tempnodefunc = cinit_tempnodefunc;
+ cinit_tempnodefunc = NULL;
+
+ state->trychain = trychain;
+ trychain = NULL;
+
+ state->cparser_fileoffset = cparser_fileoffset;
+ state->symdecltoken = symdecltoken;
+
+ state->functionbodyoffset = functionbodyoffset;
+ functionbodyoffset = 0;
+
+ state->functionbodypath = functionbodypath;
+ functionbodypath = NULL;
+
+ state->symdecloffset = symdecloffset;
+ symdecloffset = 0;
+
+ state->symdeclend = symdeclend;
+
+ state->sourceoffset = sourceoffset;
+ sourceoffset = 0;
+
+ state->sourcefilepath = sourcefilepath;
+ sourcefilepath = NULL;
+
+ state->curstmtvalue = curstmtvalue;
+ curstmtvalue = 0;
+
+ state->name_obj_check = name_obj_check;
+ name_obj_check = NULL;
+
+ state->check_arglist = check_arglist;
+ check_arglist = NULL;
+
+ state->blockcount = blockcount;
+ blockcount = 0;
+
+ state->localcount = localcount;
+ localcount = 0;
+
+ state->tk = tk;
+ state->tkidentifier = tkidentifier;
+
+ state->global_access = global_access;
+
+ state->cexcept_hasdobjects = cexcept_hasdobjects;
+ cexcept_hasdobjects = 0;
+
+ state->sinit_first_object = sinit_first_object;
+ sinit_first_object = NULL;
+
+ state->ainit_only_one = ainit_only_one;
+ ainit_only_one = 0;
+
+ state->cfunc_is_extern_c = cfunc_is_extern_c;
+ cfunc_is_extern_c = 0;
+
+ state->temp_reference_init = temp_reference_init;
+
+ return state;
+}
+
+void CFunc_SetGlobalCompilerState(CFuncSave *state) {
+ if (state) {
+ CScope_RestoreScope(&state->scope);
+
+ arguments = state->arguments;
+ locals = state->locals;
+ Labels = state->labels;
+ curstmt = state->curstmt;
+ firstblock = state->firstblock;
+ currentblock = state->currentblock;
+ cexcept_dobjstack = state->cexcept_dobjstack;
+ sinit_label = state->sinit_label;
+ ainit_expr = state->ainit_expr;
+ ctor_chain = state->ctor_chain;
+ cinit_tempnodefunc = state->cinit_tempnodefunc;
+ trychain = state->trychain;
+ name_obj_check = state->name_obj_check;
+ check_arglist = state->check_arglist;
+ curstmtvalue = state->curstmtvalue;
+ cparser_fileoffset = state->cparser_fileoffset;
+ symdecltoken = state->symdecltoken;
+ functionbodyoffset = state->functionbodyoffset;
+ functionbodypath = state->functionbodypath;
+ symdecloffset = state->symdecloffset;
+ symdeclend = state->symdeclend;
+ sourceoffset = state->sourceoffset;
+ sourcefilepath = state->sourcefilepath;
+ blockcount = state->blockcount;
+ tk = state->tk;
+ tkidentifier = state->tkidentifier;
+ global_access = state->global_access;
+ localcount = state->localcount;
+ cexcept_hasdobjects = state->cexcept_hasdobjects;
+ sinit_first_object = state->sinit_first_object;
+ ainit_only_one = state->ainit_only_one;
+ cfunc_is_extern_c = state->cfunc_is_extern_c;
+ temp_reference_init = state->temp_reference_init;
+
+ unlocklheap();
+ }
+}
+
+void CFunc_Gen(Statement *stmt, Object *func, UInt8 unk) {
+ Boolean flag;
+ CI_FuncData packed;
+
+ if ((TYPE_FUNC(func->type)->flags & FUNC_FLAGS_400000) && !anyerrors) {
+ CInline_PackIFunctionData(&packed, stmt, func);
+ flag = 1;
+ } else {
+ flag = 0;
+ }
+
+ CInline_GenFunc(stmt, func, unk);
+
+ if (flag)
+ CClass_DefineCovariantFuncs(func, &packed);
+}
+
+static void CFunc_CheckCtorInitializer(TypeClass *tclass, CtorChain *chain) {
+ ObjMemberVar *ivar;
+ CtorChain *scan;
+
+ if (tclass->mode != CLASS_MODE_1) {
+ for (ivar = tclass->ivars; ivar; ivar = ivar->next) {
+ if (IS_TYPE_REFERENCE(ivar->type)) {
+ for (scan = chain; scan; scan = scan->next) {
+ if (scan->what == CtorChain_MemberVar && scan->u.membervar == ivar)
+ break;
+ }
+
+ if (!scan)
+ CError_Error(CErrorStr256, ivar->name->name);
+ } else if (CParser_IsConst(ivar->type, ivar->qual)) {
+ for (scan = chain; scan; scan = scan->next) {
+ if (scan->what == CtorChain_MemberVar && scan->u.membervar == ivar)
+ break;
+ }
+
+ if (!scan && !IS_TYPE_CLASS(ivar->type))
+ CError_Error(CErrorStr255, ivar->name->name);
+ }
+ }
+ }
+}
+
+void CFunc_CheckClassCtors(TypeClass *tclass) {
+ CFunc_CheckCtorInitializer(tclass, NULL);
+}
+
+static void CFunc_ParseCtorInitializer(void) {
+ CtorChain *chain;
+ ENodeList *args;
+ TypeClass *tclass;
+ ObjMemberVar *ivar;
+ ClassList *base;
+ VClassList *vbase;
+ ENode *expr;
+ Type *origtype;
+
+ ctor_chain = NULL;
+
+ if (tk == ':') {
+ do {
+ tclass = NULL;
+ switch ((tk = lex())) {
+ case TK_IDENTIFIER:
+ for (ivar = cscope_currentclass->ivars; ivar; ivar = ivar->next) {
+ if (ivar->name == tkidentifier && lookahead() == '(')
+ goto do_ivar;
+ }
+ for (base = cscope_currentclass->bases; base; base = base->next) {
+ if (base->base->classname == tkidentifier) {
+ if (lookahead() == '(') {
+ tclass = base->base;
+ tk = lex();
+ } else {
+ tkidentifier = base->base->classname;
+ }
+ break;
+ }
+ }
+ break;
+
+ case TK_COLON_COLON:
+ break;
+
+ default:
+ CError_Error(CErrorStr212);
+ return;
+ }
+
+ if (!tclass)
+ tclass = CClass_GetQualifiedClass();
+
+ if (tclass) {
+ for (vbase = cscope_currentclass->vbases; vbase; vbase = vbase->next) {
+ if (vbase->base == tclass)
+ break;
+ }
+
+ if (vbase) {
+ for (chain = ctor_chain; chain; chain = chain->next) {
+ if (chain->what == CtorChain_VBase && chain->u.vbase == vbase) {
+ CError_Error(CErrorStr212);
+ return;
+ }
+ }
+
+ chain = lalloc(sizeof(CtorChain));
+ chain->what = CtorChain_VBase;
+ chain->u.vbase = vbase;
+ } else {
+ for (base = cscope_currentclass->bases; base; base = base->next) {
+ if (base->base == tclass)
+ break;
+ }
+
+ if (base) {
+ for (chain = ctor_chain; chain; chain = chain->next) {
+ if (chain->what == CtorChain_Base && chain->u.base == base) {
+ CError_Error(CErrorStr212);
+ return;
+ }
+ }
+
+ chain = lalloc(sizeof(CtorChain));
+ chain->what = CtorChain_Base;
+ chain->u.base = base;
+ } else {
+ CError_Error(CErrorStr212);
+ return;
+ }
+ }
+ } else {
+ for (ivar = cscope_currentclass->ivars; ivar; ivar = ivar->next) {
+ if (ivar->name == tkidentifier)
+ break;
+ }
+
+ if (ivar) {
+ do_ivar:
+ for (chain = ctor_chain; chain; chain = chain->next) {
+ if (chain->what == CtorChain_MemberVar && chain->u.membervar == ivar)
+ CError_Error(CErrorStr212);
+ }
+
+ chain = lalloc(sizeof(CtorChain));
+ chain->what = CtorChain_MemberVar;
+ chain->u.membervar = ivar;
+ } else {
+ CError_Error(CErrorStr212);
+ return;
+ }
+
+ tk = lex();
+ }
+
+ if (tk != '(') {
+ CError_Error(CErrorStr114);
+ return;
+ }
+
+ tk = lex();
+ args = CExpr_ScanExpressionList(1);
+
+ if (tk != ')') {
+ CError_Error(CErrorStr115);
+ return;
+ }
+
+ switch (chain->what) {
+ case CtorChain_Base:
+ expr = CABI_MakeThisExpr(NULL, chain->u.base->offset);
+ chain->objexpr = CExpr_ConstructObject(chain->u.base->base, expr, args, 1, 0, 0, 0, 1);
+ break;
+ case CtorChain_VBase:
+ expr = CABI_MakeThisExpr(chain->u.vbase->base, chain->u.vbase->offset);
+ chain->objexpr = CExpr_ConstructObject(chain->u.vbase->base, expr, args, 1, 0, 0, 0, 1);
+ break;
+ case CtorChain_MemberVar:
+ expr = CABI_MakeThisExpr(cscope_currentclass, chain->u.membervar->offset);
+ expr->flags = chain->u.membervar->qual & ENODE_FLAG_QUALS;
+ switch (chain->u.membervar->type->type) {
+ case TYPECLASS:
+ chain->objexpr = CExpr_ConstructObject(TYPE_CLASS(chain->u.membervar->type), expr, args, 1, 1, 0, 1, 1);
+ break;
+ case TYPEARRAY:
+ if (args) {
+ CError_Error(CErrorStr212);
+ continue;
+ }
+ chain->objexpr = NULL;
+ break;
+ default:
+ if (!args) {
+ args = lalloc(sizeof(ENodeList));
+ args->next = NULL;
+ args->node = CExpr_DoExplicitConversion(chain->u.membervar->type, chain->u.membervar->qual, NULL);
+ }
+ if (args->next) {
+ CError_Error(CErrorStr212);
+ return;
+ }
+ expr = makemonadicnode(expr, EINDIRECT);
+ expr->rtype = chain->u.membervar->type;
+ if (IS_TYPE_BITFIELD(origtype = expr->rtype)) {
+ expr->data.monadic = makemonadicnode(expr->data.monadic, EBITFIELD);
+ expr->data.monadic->rtype = origtype;
+ expr->rtype = TYPE_BITFIELD(origtype)->bitfieldtype;
+ }
+
+ chain->objexpr = makediadicnode(expr, CExpr_AssignmentPromotion(args->node, expr->rtype, expr->flags, 1), EASS);
+ }
+ break;
+ default:
+ CError_FATAL(3286);
+ }
+
+ chain->next = ctor_chain;
+ ctor_chain = chain;
+ } while ((tk = lex()) == ',');
+ }
+}
+
+static void CFunc_FunctionRedefinedCheck(Object *func) {
+ if (TYPE_FUNC(func->type)->flags & FUNC_FLAGS_100)
+ CError_Error(CErrorStr333, func);
+
+ if ((TYPE_FUNC(func->type)->flags & FUNC_FLAGS_2) && func->datatype != DINLINEFUNC)
+ CError_Error(CErrorStr333, func);
+
+ TYPE_FUNC(func->type)->flags |= FUNC_FLAGS_2;
+}
+
+static Object *CFunc_DeclareFuncName(char *str, HashNameNode *name) {
+ Object *obj;
+ Object *aliasobj;
+ DeclInfo di;
+
+ memclrw(&di, sizeof(di));
+ di.name = name;
+ di.storageclass = TK_STATIC;
+ di.qual = Q_CONST;
+ di.thetype = CDecl_NewArrayType(TYPE(&stchar), strlen(str) + 1);
+
+ obj = CParser_NewGlobalDataObject(&di);
+ aliasobj = CParser_NewAliasObject(obj, 0);
+ obj->nspace = cscope_root;
+ obj->datatype = DDATA;
+ CFunc_NameLocalStaticDataObject(obj, obj->name->name);
+
+ return aliasobj;
+}
+
+void CFunc_ParseFuncDef(Object *func, DeclInfo *di, TypeClass *tclass, Boolean is_method, Boolean is_static, NameSpace *nspace) {
+ Boolean has_try;
+ Object *nameobj_func;
+ Object *nameobj_FUNCTION;
+ Object *nameobj_pretty;
+ char *prettyname;
+ Statement *stmt18;
+ Statement *stmt16;
+ Statement firstStmt;
+ DeclThing thing;
+ CScopeSave scope;
+
+ nameobj_func = NULL;
+ nameobj_FUNCTION = NULL;
+ nameobj_pretty = NULL;
+ prettyname = NULL;
+
+ CError_ASSERT(3373, IS_TYPE_FUNC(func->type));
+
+ CFunc_FunctionRedefinedCheck(func);
+ CParser_UpdateObject(func, di);
+
+ if (!is_method) {
+ CScope_SetFunctionScope(func, &scope);
+ if (tclass)
+ cscope_current = tclass->nspace;
+ } else {
+ CScope_SetMethodScope(func, tclass, is_static, &scope);
+ }
+
+ if (nspace)
+ cscope_current = nspace;
+
+ if (cscope_currentclass)
+ CClass_MemberDef(func, cscope_currentclass);
+
+ cfunc_is_extern_c = di->x4E;
+
+ CError_ASSERT(3392, IS_TYPE_FUNC(func->type));
+ if (di->x45 && (func->qual & Q_ASM))
+ CError_Error(CErrorStr176);
+
+ if (cparamblkptr->isPrecompiling == 1 && !(func->qual & Q_INLINE))
+ CError_ErrorTerm(CErrorStr180);
+
+ if (di->x49)
+ CError_Error(CErrorStr127);
+
+ CFunc_FuncGenSetup(&firstStmt, func);
+ if (!IS_TYPE_VOID(TYPE_FUNC(func->type)->functype))
+ IsCompleteType(TYPE_FUNC(func->type)->functype);
+
+ SetupFunctionArguments(func, di, &firstStmt);
+
+ stmt18 = curstmt;
+ CPrep_GetFileOffsetInfo2(&cparser_fileoffset, &sourceoffset, &sourcefilepath);
+ functionbodyoffset = sourceoffset;
+ firstStmt.sourceoffset = sourceoffset;
+ functionbodypath = sourcefilepath;
+ firstStmt.sourcefilepath = sourcefilepath;
+
+ if (di->x45)
+ CFunc_AdjustOldStyleArgs();
+
+ if (di->x1C)
+ CScope_MergeNameSpace(cscope_current, di->x1C);
+
+ if (tk == TK_TRY) {
+ tk = lex();
+ has_try = 1;
+ } else {
+ has_try = 0;
+ }
+
+ if (CClass_IsConstructor(func)) {
+ CError_ASSERT(3445, cscope_currentclass);
+ CFunc_ParseCtorInitializer();
+ CFunc_CheckCtorInitializer(cscope_currentclass, ctor_chain);
+ }
+
+ CPrep_TokenStreamFlush();
+
+ if (!(func->qual & Q_ASM)) {
+ if (tk == '{') {
+ if (!has_try)
+ tk = lex();
+ } else {
+ CError_ErrorSkip(CErrorStr135);
+ has_try = 0;
+ }
+
+ if (func->name) {
+ nameobj_func = CFunc_DeclareFuncName(func->name->name, GetHashNameNode("__func__"));
+ nameobj_FUNCTION = CFunc_DeclareFuncName(func->name->name, GetHashNameNode("__FUNCTION__"));
+ prettyname = CError_GetObjectName(func);
+ nameobj_pretty = CFunc_DeclareFuncName(prettyname, GetHashNameNode("__PRETTY_FUNCTION__"));
+ }
+
+ if (!copts.cplusplus)
+ CFunc_ParseLocalDeclarationList(0, 0, 0, 0);
+
+ thing.switchinfo = NULL;
+ thing.loopContinue = NULL;
+ thing.loopBreak = NULL;
+ thing.thetype = TYPE_FUNC(func->type)->functype;
+ thing.qual = TYPE_FUNC(func->type)->qual;
+
+ if (has_try) {
+ CExcept_ScanTryBlock(&thing, CClass_IsConstructor(func) || CClass_IsDestructor(func));
+ if (tk != 0)
+ CPrep_UnLex();
+ tk = '}';
+ } else {
+ while (tk != '}')
+ statement(&thing);
+ }
+
+ stmt16 = curstmt;
+
+ if (stmt16->type != ST_RETURN && stmt16->type != ST_GOTO) {
+ CPrep_GetFileOffsetInfo2(&cparser_fileoffset, &sourceoffset, &sourcefilepath);
+ CFunc_AppendStatement(ST_RETURN);
+
+ curstmt->dobjstack = NULL;
+ curstmt->expr = NULL;
+
+ if (
+ (copts.cplusplus || copts.c9x) &&
+ !strcmp(func->name->name, "main") &&
+ TYPE_FUNC(func->type)->functype == TYPE(&stsignedint)
+ )
+ curstmt->expr = intconstnode(TYPE(&stsignedint), 0);
+
+ if (
+ stmt16->type == ST_EXPRESSION &&
+ stmt16->expr->type == EFUNCCALL &&
+ stmt16->expr->rtype == &stvoid &&
+ (stmt16->expr->flags & ENODE_FLAG_VOLATILE)
+ )
+ curstmt->flags |= StmtFlag_8;
+ }
+
+ CheckCLabels();
+
+ if (nameobj_func && (nameobj_func->flags & OBJECT_FLAGS_UNUSED))
+ CInit_DeclareData(nameobj_func->u.alias.object, func->name->name, NULL, strlen(func->name->name) + 1);
+ if (nameobj_FUNCTION && (nameobj_FUNCTION->flags & OBJECT_FLAGS_UNUSED))
+ CInit_DeclareData(nameobj_FUNCTION->u.alias.object, func->name->name, NULL, strlen(func->name->name) + 1);
+ if (nameobj_pretty && (nameobj_pretty->flags & OBJECT_FLAGS_UNUSED))
+ CInit_DeclareData(nameobj_pretty->u.alias.object, prettyname, NULL, strlen(prettyname) + 1);
+
+ if (!fatalerrors) {
+ if (CClass_IsConstructor(func))
+ CABI_TransConstructor(func, stmt18, cscope_currentclass, NULL, has_try);
+ if (CClass_IsDestructor(func))
+ CABI_TransDestructor(func, func, &firstStmt, cscope_currentclass, 0);
+
+ CFunc_DestructorCleanup(&firstStmt);
+ CFunc_CodeCleanup(&firstStmt);
+ symdeclend = CPrep_GetFileOffsetInfo(&cparser_fileoffset);
+ CFunc_Gen(&firstStmt, func, di->x45);
+ }
+ } else {
+ if (tk == '{') {
+ in_assembler = 1;
+ tk = lex();
+ in_assembler = 0;
+ } else {
+ CError_ErrorSkip(CErrorStr135);
+ }
+
+ CFunc_ParseLocalDeclarationList(1, 0, 0, 0);
+ Assembler(func);
+ }
+
+ if (tk != '}')
+ CError_Error(CErrorStr130);
+
+ CScope_RestoreScope(&scope);
+}
+
+void InitExpr_Register(ENode *expr, Object *object) {
+ InitExpr *initexpr;
+ InitExpr *scan;
+
+ if (
+ cparamblkptr->isPrecompiling == 1 &&
+ object->sclass != TK_STATIC &&
+ !(object->qual & (Q_20000 | Q_OVERLOAD))
+ )
+ {
+ CError_Error(CErrorStr180);
+ return;
+ }
+
+ if (copts.suppress_init_code)
+ return;
+
+ initexpr = galloc(sizeof(InitExpr));
+ initexpr->next = NULL;
+ initexpr->object = object;
+ initexpr->expr = CInline_CopyExpression(expr, CopyMode1);
+
+ if (init_expressions) {
+ scan = init_expressions;
+ while (scan->next)
+ scan = scan->next;
+ scan->next = initexpr;
+ } else {
+ init_expressions = initexpr;
+ }
+}
+
+void CFunc_GenerateDummyFunction(Object *func) {
+ NameSpace *nspace;
+ Boolean saveDebugInfo;
+ Statement firstStmt;
+
+ if (!anyerrors) {
+ nspace = CFunc_FuncGenSetup(&firstStmt, NULL);
+
+ saveDebugInfo = copts.isGeneratingDebugInfo;
+ copts.isGeneratingDebugInfo = 0;
+
+ CFunc_CodeCleanup(&firstStmt);
+ CFunc_Gen(&firstStmt, func, 0);
+
+ cscope_current = nspace->parent;
+ copts.isGeneratingDebugInfo = saveDebugInfo;
+ }
+}
+
+void CFunc_GenerateSingleExprFunc(Object *func, ENode *expr) {
+ NameSpace *nspace;
+ Boolean saveDebugInfo;
+ Statement firstStmt;
+ Statement *stmt;
+
+ if (cparamblkptr->isPrecompiling == 1) {
+ CError_Error(CErrorStr180);
+ return;
+ }
+
+ if (!anyerrors) {
+ nspace = CFunc_FuncGenSetup(&firstStmt, func);
+
+ saveDebugInfo = copts.isGeneratingDebugInfo;
+ copts.isGeneratingDebugInfo = 0;
+
+ stmt = CFunc_AppendStatement(ST_EXPRESSION);
+ stmt->expr = expr;
+
+ CFunc_CodeCleanup(&firstStmt);
+ CInline_GenFunc(&firstStmt, func, 0);
+
+ cscope_current = nspace->parent;
+ copts.isGeneratingDebugInfo = saveDebugInfo;
+ }
+}
+
+void CFunc_GenerateDummyCtorFunc(Object *func, Object *real_ctor) {
+ ENode *expr;
+ NameSpace *nspace;
+ FuncArg *arg1;
+ FuncArg *arg0;
+ ENodeList *list;
+ Boolean saveDebugInfo;
+ Statement firstStmt;
+ Statement *stmt;
+
+ if (cparamblkptr->isPrecompiling == 1) {
+ CError_Error(CErrorStr180);
+ return;
+ }
+
+ if (!anyerrors) {
+ cscope_currentfunc = func;
+
+ nspace = CFunc_FuncGenSetup(&firstStmt, func);
+
+ saveDebugInfo = copts.isGeneratingDebugInfo;
+ copts.isGeneratingDebugInfo = 0;
+
+ CFunc_SetupNewFuncArgs(func, TYPE_FUNC(func->type)->args);
+
+ expr = CExpr_NewENode(EFUNCCALL);
+ expr->type = EFUNCCALL;
+ expr->cost = 200;
+ expr->rtype = TYPE(&void_ptr);
+ expr->data.funccall.funcref = CExpr_MakeObjRefNode(real_ctor, 0);
+ expr->data.funccall.functype = TYPE_FUNC(func->type);
+
+ CError_ASSERT(3716, IS_TYPE_FUNC(real_ctor->type));
+ CError_ASSERT(3717, TYPE_FUNC(real_ctor->type)->flags & FUNC_FLAGS_METHOD);
+ CError_ASSERT(3718, arg0 = TYPE_FUNC(real_ctor->type)->args);
+ CError_ASSERT(3720, arg1 = arg0->next);
+ CError_ASSERT(3721, arguments);
+
+ list = lalloc(sizeof(ENodeList));
+ expr->data.funccall.args = list;
+ list->node = create_objectnode(arguments->object);
+
+ if (TYPE_METHOD(real_ctor->type)->theclass->flags & CLASS_FLAGS_20) {
+ CError_ASSERT(3727, arg1 = arg1->next);
+ CError_ASSERT(3728, arguments->next);
+ list->next = lalloc(sizeof(ENodeList));
+ list = list->next;
+ list->node = create_objectnode(arguments->next->object);
+ }
+
+ while (arg1) {
+ CError_ASSERT(3737, arg1->dexpr);
+ list->next = lalloc(sizeof(ENodeList));
+ list = list->next;
+ list->node = CExpr_GetDefaultArgument(expr->data.funccall.funcref, arg1);
+ arg1 = arg1->next;
+ }
+
+ list->next = NULL;
+
+ stmt = CFunc_AppendStatement(ST_RETURN);
+ stmt->expr = expr;
+
+ CFunc_CodeCleanup(&firstStmt);
+ CInline_GenFunc(&firstStmt, func, 0);
+
+ cscope_current = nspace->parent;
+ cscope_currentfunc = NULL;
+ copts.isGeneratingDebugInfo = saveDebugInfo;
+ }
+}
diff --git a/compiler_and_linker/unsorted/CInit.c b/compiler_and_linker/unsorted/CInit.c
index ccc534e..a76bdab 100644
--- a/compiler_and_linker/unsorted/CInit.c
+++ b/compiler_and_linker/unsorted/CInit.c
@@ -3,25 +3,21 @@
#include "compiler/CClass.h"
#include "compiler/CDecl.h"
#include "compiler/CError.h"
+#include "compiler/CException.h"
#include "compiler/CExpr.h"
#include "compiler/CInline.h"
#include "compiler/CInt64.h"
#include "compiler/CMachine.h"
#include "compiler/CParser.h"
+#include "compiler/CPrec.h"
#include "compiler/CPrep.h"
#include "compiler/CPrepTokenizer.h"
#include "compiler/CScope.h"
#include "compiler/CompilerTools.h"
+#include "compiler/ObjGenMachO.h"
#include "compiler/objects.h"
#include "compiler/types.h"
-// TODO - move me!!
-extern void PreComp_StaticData(Object *obj, void *data, OLinkList *list, SInt32 size);
-extern void ObjGen_DeclareReadOnlyData(Object *obj, void *data, OLinkList *list, SInt32 size);
-extern void ObjGen_DeclareData(Object *obj, void *data, OLinkList *list, SInt32 size);
-extern void CExcept_RegisterDestructorObject(Object *obj, SInt32 offset, Object *dtor, Boolean flag);
-extern void CExcept_RegisterLocalArray(Statement *stmt, Object *obj, Object *dtor, SInt32 count, SInt32 size);
-
TempNodeCB cinit_tempnodefunc;
InitInfo *cinit_initinfo;
static PooledString *cinit_stringlist;
@@ -803,7 +799,7 @@ static void CInit_InitTypeArray(CInit_Stuff *s, CInit_Stuff2 *s2, TypePointer *t
}
}
-static void CInit_InitTypeStruct(CInit_Stuff *s, CInit_Stuff2 *s2, TypeStruct *tstruct, UInt32 qual, Boolean errorflag) {
+static void CInit_InitTypeStruct(CInit_Stuff *s, CInit_Stuff2 *s2, const TypeStruct *tstruct, UInt32 qual, Boolean errorflag) {
StructMember *member;
SInt32 start;
Boolean flag;
@@ -1257,7 +1253,7 @@ static ENode *CInit_RegisterDtorObject(Type *type, Object *dtor, ENode *objexpr)
expr->data.funccall.args = lalloc(sizeof(ENodeList));
expr->data.funccall.args->node = objexpr;
expr->data.funccall.args->next = lalloc(sizeof(ENodeList));
- expr->data.funccall.args->next->node = create_objectrefnode(CABI_GetDestructorObject(dtor, 1));
+ expr->data.funccall.args->next->node = create_objectrefnode(CABI_GetDestructorObject(dtor, CABIDestroy1));
expr->data.funccall.args->next->next = lalloc(sizeof(ENodeList));
expr->data.funccall.args->next->next->node = create_objectrefnode(CInit_CreateStaticData(CInit_GetRegMemType()));
expr->data.funccall.args->next->next->next = NULL;
@@ -1266,7 +1262,7 @@ static ENode *CInit_RegisterDtorObject(Type *type, Object *dtor, ENode *objexpr)
}
static Boolean CInit_ConstructGlobalObject(Object *obj, TypeClass *tclass, ENode *valueexpr, SInt32 offset, Boolean flag) {
- Object *ctor;
+ NameSpaceObjectList *ctor;
Object *dtor;
ENodeList *list;
ENode *expr;
@@ -1336,7 +1332,7 @@ static Boolean CInit_ConstructGlobalObject(Object *obj, TypeClass *tclass, ENode
static Boolean CInit_ConstructAutoObject(TypeClass *tclass, ENode *expr, SInt32 offset, Boolean flag) {
ENodeList *r30;
ENode *r29;
- Object *ctor;
+ NameSpaceObjectList *ctor;
Object *dtor;
Boolean r24;
@@ -1920,7 +1916,7 @@ static void CInit_AutoInit(Type *type, ENode *valueexpr, Boolean flag) {
copy = galloc(sizeof(TypePointer));
*TYPE_POINTER(copy) = *TYPE_POINTER(type);
type = copy;
- copy->size = type->size + 1;
+ type->size++;
}
expr = create_objectrefnode(cinit_initinfo->obj1C);
if (!IS_TYPE_POINTER_ONLY(expr->rtype)) {
@@ -2163,7 +2159,7 @@ Statement *CInit_ConstructClassArray(Statement *stmt, TypeClass *tclass, Object
stmt = CFunc_AppendStatement(ST_EXPRESSION);
if (dtor)
- dtor_expr = create_objectrefnode(CABI_GetDestructorObject(dtor, 1));
+ dtor_expr = create_objectrefnode(CABI_GetDestructorObject(dtor, CABIDestroy1));
else
dtor_expr = nullnode();
@@ -2236,7 +2232,7 @@ static void CInit_InitializeClassArray(Object *obj, TypeClass *tclass, Boolean f
expr = nullnode();
} else {
if (dtor)
- dtor_expr = create_objectrefnode(CABI_GetDestructorObject(dtor, 1));
+ dtor_expr = create_objectrefnode(CABI_GetDestructorObject(dtor, CABIDestroy1));
else
dtor_expr = nullnode();
expr = CExpr_FuncCallSix(
@@ -2270,7 +2266,7 @@ static void CInit_InitializeClassArray(Object *obj, TypeClass *tclass, Boolean f
CParser_RegisterSingleExprFunction(funcobj, funccallexpr(
darr_func,
create_objectrefnode(obj),
- create_objectrefnode(CABI_GetDestructorObject(dtor, 1)),
+ create_objectrefnode(CABI_GetDestructorObject(dtor, CABIDestroy1)),
intconstnode(TYPE(&stsignedlong), tclass->size),
intconstnode(TYPE(&stsignedlong), count)
));
@@ -2330,7 +2326,7 @@ static ENode *CInit_GlobalTempNode(Type *type, Boolean flag) {
funcnode->data.funccall.args = lalloc(sizeof(ENodeList));
funcnode->data.funccall.args->node = node;
funcnode->data.funccall.args->next = lalloc(sizeof(ENodeList));
- funcnode->data.funccall.args->next->node = create_objectrefnode(CABI_GetDestructorObject(dtor, 1));
+ funcnode->data.funccall.args->next->node = create_objectrefnode(CABI_GetDestructorObject(dtor, CABIDestroy1));
funcnode->data.funccall.args->next->next = lalloc(sizeof(ENodeList));
funcnode->data.funccall.args->next->next->node = create_objectrefnode(CInit_CreateStaticData(CInit_GetRegMemType()));;
funcnode->data.funccall.args->next->next->next = NULL;
@@ -2641,7 +2637,7 @@ void CInit_InitializeAutoData(Object *obj, InsertExprCB insert_cb, RegisterObjec
}
if (IS_TYPE_CLASS(obj->type) && CClass_Destructor(TYPE_CLASS(obj->type)))
- register_cb(obj->type, obj, 0, NULL);
+ register_cb(obj->type, obj, 0, 0);
CInit_CleanupInitInfo(&initinfo);
}
diff --git a/compiler_and_linker/unsorted/CMangler.c b/compiler_and_linker/unsorted/CMangler.c
index e3e3c3e..c1b9618 100644
--- a/compiler_and_linker/unsorted/CMangler.c
+++ b/compiler_and_linker/unsorted/CMangler.c
@@ -47,54 +47,54 @@ HashNameNode *CMangler_DeleteDtorName(void) {
return GetHashNameNodeExport("__dt");
}
-char *CMangler_GetOperator(HashNameNode *opname) {
- char *name;
+char *CMangler_GetOperator(HashNameNode *name) {
+ char *str;
- if (opname == asop_name_node)
+ if (name == asop_name_node)
return "operator=";
- name = opname->name;
- if (!strcmp(name, "__nw")) return "operator new";
- if (!strcmp(name, "__dl")) return "operator delete";
- if (!strcmp(name, "__nwa")) return "operator new[]";
- if (!strcmp(name, "__dla")) return "operator delete[]";
- if (!strcmp(name, "__pl")) return "operator+";
- if (!strcmp(name, "__mi")) return "operator-";
- if (!strcmp(name, "__ml")) return "operator*";
- if (!strcmp(name, "__dv")) return "operator/";
- if (!strcmp(name, "__md")) return "operator%";
- if (!strcmp(name, "__er")) return "operator^";
- if (!strcmp(name, "__ad")) return "operator&";
- if (!strcmp(name, "__or")) return "operator|";
- if (!strcmp(name, "__co")) return "operator~";
- if (!strcmp(name, "__nt")) return "operator!";
- if (!strcmp(name, "__lt")) return "operator<";
- if (!strcmp(name, "__gt")) return "operator>";
- if (!strcmp(name, "__apl")) return "operator+=";
- if (!strcmp(name, "__ami")) return "operator-=";
- if (!strcmp(name, "__amu")) return "operator*=";
- if (!strcmp(name, "__adv")) return "operator/=";
- if (!strcmp(name, "__amd")) return "operator%=";
- if (!strcmp(name, "__aer")) return "operator^=";
- if (!strcmp(name, "__aad")) return "operator&=";
- if (!strcmp(name, "__aor")) return "operator|=";
- if (!strcmp(name, "__ls")) return "operator<<";
- if (!strcmp(name, "__rs")) return "operator>>";
- if (!strcmp(name, "__als")) return "operator<<=";
- if (!strcmp(name, "__ars")) return "operator>>=";
- if (!strcmp(name, "__eq")) return "operator==";
- if (!strcmp(name, "__ne")) return "operator!=";
- if (!strcmp(name, "__le")) return "operator<=";
- if (!strcmp(name, "__ge")) return "operator>=";
- if (!strcmp(name, "__aa")) return "operator&&";
- if (!strcmp(name, "__oo")) return "operator||";
- if (!strcmp(name, "__pp")) return "operator++";
- if (!strcmp(name, "__mm")) return "operator--";
- if (!strcmp(name, "__cm")) return "operator,";
- if (!strcmp(name, "__rm")) return "operator->*";
- if (!strcmp(name, "__rf")) return "operator*";
- if (!strcmp(name, "__cl")) return "operator()";
- if (!strcmp(name, "__vc")) return "operator[]";
+ str = name->name;
+ if (!strcmp(str, "__nw")) return "operator new";
+ if (!strcmp(str, "__dl")) return "operator delete";
+ if (!strcmp(str, "__nwa")) return "operator new[]";
+ if (!strcmp(str, "__dla")) return "operator delete[]";
+ if (!strcmp(str, "__pl")) return "operator+";
+ if (!strcmp(str, "__mi")) return "operator-";
+ if (!strcmp(str, "__ml")) return "operator*";
+ if (!strcmp(str, "__dv")) return "operator/";
+ if (!strcmp(str, "__md")) return "operator%";
+ if (!strcmp(str, "__er")) return "operator^";
+ if (!strcmp(str, "__ad")) return "operator&";
+ if (!strcmp(str, "__or")) return "operator|";
+ if (!strcmp(str, "__co")) return "operator~";
+ if (!strcmp(str, "__nt")) return "operator!";
+ if (!strcmp(str, "__lt")) return "operator<";
+ if (!strcmp(str, "__gt")) return "operator>";
+ if (!strcmp(str, "__apl")) return "operator+=";
+ if (!strcmp(str, "__ami")) return "operator-=";
+ if (!strcmp(str, "__amu")) return "operator*=";
+ if (!strcmp(str, "__adv")) return "operator/=";
+ if (!strcmp(str, "__amd")) return "operator%=";
+ if (!strcmp(str, "__aer")) return "operator^=";
+ if (!strcmp(str, "__aad")) return "operator&=";
+ if (!strcmp(str, "__aor")) return "operator|=";
+ if (!strcmp(str, "__ls")) return "operator<<";
+ if (!strcmp(str, "__rs")) return "operator>>";
+ if (!strcmp(str, "__als")) return "operator<<=";
+ if (!strcmp(str, "__ars")) return "operator>>=";
+ if (!strcmp(str, "__eq")) return "operator==";
+ if (!strcmp(str, "__ne")) return "operator!=";
+ if (!strcmp(str, "__le")) return "operator<=";
+ if (!strcmp(str, "__ge")) return "operator>=";
+ if (!strcmp(str, "__aa")) return "operator&&";
+ if (!strcmp(str, "__oo")) return "operator||";
+ if (!strcmp(str, "__pp")) return "operator++";
+ if (!strcmp(str, "__mm")) return "operator--";
+ if (!strcmp(str, "__cm")) return "operator,";
+ if (!strcmp(str, "__rm")) return "operator->*";
+ if (!strcmp(str, "__rf")) return "operator*";
+ if (!strcmp(str, "__cl")) return "operator()";
+ if (!strcmp(str, "__vc")) return "operator[]";
return NULL;
}
@@ -146,12 +146,12 @@ HashNameNode *CMangler_OperatorName(short token) {
}
}
-HashNameNode *CMangler_VTableName(TypeClass *tclass) {
+HashNameNode *CMangler_VTableName(TypeClass *theclass) {
HashNameNode *name;
name_mangle_list.size = 0;
AppendGListName(&name_mangle_list, "__vt__");
- CMangler_MangleClassName(tclass);
+ CMangler_MangleClassName(theclass);
AppendGListByte(&name_mangle_list, 0);
COS_LockHandle(name_mangle_list.data);
name = GetHashNameNodeExport(*name_mangle_list.data);
@@ -172,20 +172,20 @@ HashNameNode *CMangler_RTTIObjectName(Type *type, UInt32 qual) {
return name;
}
-HashNameNode *CMangler_ThunkName(Object *obj, int a, int b, int c) {
+HashNameNode *CMangler_ThunkName(Object *vfunc, SInt32 this_delta, SInt32 return_delta, SInt32 ctoroffset) {
HashNameNode *linkname;
HashNameNode *name;
char buf[64];
- linkname = CMangler_GetLinkName(obj);
+ linkname = CMangler_GetLinkName(vfunc);
name_mangle_list.size = 0;
- if (b == 0) {
- if (c < 0)
- sprintf(buf, "_@%ld@", -a);
+ if (return_delta == 0) {
+ if (ctoroffset < 0)
+ sprintf(buf, "_@%ld@", -this_delta);
else
- sprintf(buf, "_@%ld@%ld@", -a, c);
+ sprintf(buf, "_@%ld@%ld@", -this_delta, ctoroffset);
} else {
- sprintf(buf, "_@%ld@%ld@%ld@", -a, c, b);
+ sprintf(buf, "_@%ld@%ld@%ld@", -this_delta, ctoroffset, return_delta);
}
AppendGListName(&name_mangle_list, buf);
AppendGListID(&name_mangle_list, linkname->name + 1);
@@ -640,15 +640,14 @@ static HashNameNode *CMangler_FunctionLinkName(Object *obj) {
return name;
}
-HashNameNode *CMangler_GetCovariantFunctionName(Object *obj, Type *type) {
- HashNameNode *linkname;
+HashNameNode *CMangler_GetCovariantFunctionName(Object *dobj, TypeClass *theclass) {
HashNameNode *name;
- linkname = CMangler_GetLinkName(obj);
+ name = CMangler_GetLinkName(dobj);
name_mangle_list.size = 0;
- AppendGListName(&name_mangle_list, linkname->name);
+ AppendGListName(&name_mangle_list, name->name);
AppendGListName(&name_mangle_list, "@@");
- CMangler_MangleTypeAppend(type, 0);
+ CMangler_MangleTypeAppend(TYPE(theclass), 0);
AppendGListByte(&name_mangle_list, 0);
COS_LockHandle(name_mangle_list.data);
diff --git a/compiler_and_linker/unsorted/CParser.c b/compiler_and_linker/unsorted/CParser.c
index 8228159..85ccf26 100644
--- a/compiler_and_linker/unsorted/CParser.c
+++ b/compiler_and_linker/unsorted/CParser.c
@@ -8,46 +8,26 @@
#include "compiler/CInit.h"
#include "compiler/CInline.h"
#include "compiler/CInt64.h"
+#include "compiler/CIRTransform.h"
#include "compiler/CMachine.h"
#include "compiler/CMangler.h"
+#include "compiler/CObjC.h"
#include "compiler/CPrep.h"
#include "compiler/CPrepTokenizer.h"
#include "compiler/CScope.h"
+#include "compiler/CSOM.h"
+#include "compiler/CTemplateNew.h"
+#include "compiler/CTemplateTools.h"
#include "compiler/CodeGen.h"
#include "compiler/CompilerTools.h"
+#include "compiler/IrOptimizer.h"
+#include "compiler/IroPointerAnalysis.h"
+#include "compiler/ObjGenMachO.h"
#include "compiler/objects.h"
#include "compiler/scopes.h"
#include "compiler/templates.h"
#include "cos.h"
-// TODO MOVE ME
-extern SInt32 symdecloffset;
-extern void CSOM_Setup(Boolean is_precompiler);
-extern void CSOM_Cleanup(void);
-extern void CIRTrans_Setup(void);
-extern void CObjC_Setup(void);
-extern void CObjC_GenerateModule(void);
-extern Type *CObjC_ParseTypeProtocol(Type *type);
-extern void CObjC_ParseProtocol(void);
-extern void CObjC_ParseClassDeclaration(void);
-extern void CObjC_ParseInterface(void);
-extern void CObjC_ParseImplementation(void);
-extern void CTempl_Setup(void);
-extern void CTempl_Parse(TypeClass *tclass, short access);
-extern Boolean CTempl_Instantiate(void);
-extern Boolean CInline_GenerateDeferredFuncs(void);
-extern void CTempl_Cleanup();
-extern void CIRTrans_Cleanup();
-extern void CObjC_Cleanup();
-extern void PointerAnalysis_ParseFunctionModifiesSpecifier(DeclInfo *declinfo);
-extern void PointerAnalysis_ParseExitPointsToSpecifier(DeclInfo *declinfo);
-extern void PointerAnalysis_ParseEntryPointsToSpecifier(DeclInfo *declinfo);
-extern Boolean CTemplTool_TemplDepTypeCompare(TypeTemplDep *a, TypeTemplDep *b);
-extern Boolean CTemplTool_IsSameTemplateType(Type *a, Type *b);
-extern TemplStack *ctempl_curinstance;
-extern Type *CObjC_ParseID(void);
-extern void CodeGen_UpdateOptimizerOptions(void);
-
FileOffsetInfo cparser_fileoffset;
TStreamElement symdecltoken;
ParserTryBlock *trychain;
@@ -276,16 +256,14 @@ static void CParser_SetupRuntimeObjects(void) {
func = CParser_NewRTFunc(
TYPE(&stvoid), CMangler_OperatorName(TK_DELETE), 1,
1, &void_ptr);
-#line 379
- CError_ASSERT(IS_TYPE_FUNC(func->type));
+ CError_ASSERT(379, IS_TYPE_FUNC(func->type));
TYPE_FUNC(func->type)->exspecs = exspecs;
CScope_AddGlobalObject(func);
func = CParser_NewRTFunc(
TYPE(&stvoid), CMangler_OperatorName(TK_DELETE_ARRAY), 1,
1, &void_ptr);
-#line 387
- CError_ASSERT(IS_TYPE_FUNC(func->type));
+ CError_ASSERT(387, IS_TYPE_FUNC(func->type));
TYPE_FUNC(func->type)->exspecs = exspecs;
CScope_AddGlobalObject(func);
@@ -374,8 +352,7 @@ static void CParser_SetupRuntimeObjects(void) {
1, &void_ptr);
CodeGen_SetupRuntimeObjects();
-#line 534
- CError_ASSERT(CParser_ReInitRuntimeObjects(0));
+ CError_ASSERT(534, CParser_ReInitRuntimeObjects(0));
}
void CParser_Setup(void) {
@@ -825,8 +802,7 @@ FuncArg *CParser_NewFuncArg(void) {
Type *atomtype(void) {
switch (tksize) {
default:
-#line 1145
- CError_FATAL();
+ CError_FATAL(1145);
case ATOM_VOID: return &stvoid;
case ATOM_CHAR: return TYPE(&stchar);
case ATOM_WCHAR: return TYPE(&stwchar);
@@ -853,8 +829,8 @@ Object *CParser_FindDeallocationObject(Type *type, FuncArg *args, Boolean flag1,
CScopeParseResult pr;
Boolean first_time;
Boolean retry_flag;
- Type *sizet;
Object *obj;
+ Type *sizet;
list = NULL;
*outflag = 0;
@@ -867,13 +843,11 @@ Object *CParser_FindDeallocationObject(Type *type, FuncArg *args, Boolean flag1,
mylist.object = pr.obj_10;
list = &mylist;
} else {
-#line 1202
- CError_ASSERT(pr.nsol_14);
+ CError_ASSERT(1202, pr.nsol_14);
list = pr.nsol_14;
}
} else if (TYPE_CLASS(type)->flags & CLASS_FLAGS_1) {
-#line 1210
- CError_ASSERT(!args && !flag1);
+ CError_ASSERT(1210, !args && !flag1);
return delh_func;
}
}
@@ -894,8 +868,7 @@ Object *CParser_FindDeallocationObject(Type *type, FuncArg *args, Boolean flag1,
return obj;
}
-#line 1231
- CError_ASSERT(first_time);
+ CError_ASSERT(1231, first_time);
sizet = CABI_GetSizeTType();
for (scan = list; scan; scan = scan->next) {
@@ -1014,19 +987,14 @@ short is_memberpointerequal(Type *a, Type *b) {
if ((TYPE_FUNC(a)->flags & (FUNC_FLAGS_F0000000 | FUNC_FLAGS_PASCAL)) != (TYPE_FUNC(b)->flags & (FUNC_FLAGS_F0000000 | FUNC_FLAGS_PASCAL)))
return 0;
-#line 1345
- CError_ASSERT((arg_a = TYPE_FUNC(a)->args));
- CError_ASSERT((arg_b = TYPE_FUNC(b)->args));
+ CError_ASSERT(1345, arg_a = TYPE_FUNC(a)->args);
+ CError_ASSERT(1346, arg_b = TYPE_FUNC(b)->args);
- if (TYPE_FUNC(a)->flags & FUNC_FLAGS_80) {
-#line 1351
- CError_ASSERT((arg_a = arg_a->next));
- }
+ if (TYPE_FUNC(a)->flags & FUNC_FLAGS_80)
+ CError_ASSERT(1351, arg_a = arg_a->next);
- if (TYPE_FUNC(b)->flags & FUNC_FLAGS_80) {
-#line 1355
- CError_ASSERT((arg_b = arg_b->next));
- }
+ if (TYPE_FUNC(b)->flags & FUNC_FLAGS_80)
+ CError_ASSERT(1355, arg_b = arg_b->next);
if (arg_a->qual != arg_b->qual)
return 0;
@@ -1082,8 +1050,7 @@ restart:
case TYPETEMPLATE:
return CTemplTool_TemplDepTypeCompare(TYPE_TEMPLATE(a), TYPE_TEMPLATE(b));
default:
-#line 1441
- CError_FATAL();
+ CError_FATAL(1441);
return 0;
}
}
@@ -1135,8 +1102,7 @@ short iscpp_typeequal(Type *a, Type *b) {
case TYPETEMPLATE:
return CTemplTool_TemplDepTypeCompare(TYPE_TEMPLATE(a), TYPE_TEMPLATE(b));
default:
-#line 1500
- CError_FATAL();
+ CError_FATAL(1500);
return 0;
}
}
@@ -1311,10 +1277,9 @@ restart:
return 0;
if ((TYPE_FUNC(a)->flags & (FUNC_FLAGS_F0000000 | FUNC_FLAGS_PASCAL)) != (TYPE_FUNC(b)->flags & (FUNC_FLAGS_F0000000 | FUNC_FLAGS_PASCAL)))
return 0;
- return is_arglistequal(TYPE_FUNC(a)->args, TYPE_FUNC(b)->args);
+ return is_arglistsame(TYPE_FUNC(a)->args, TYPE_FUNC(b)->args);
default:
-#line 1709
- CError_FATAL();
+ CError_FATAL(1709);
return 0;
}
}
@@ -1336,8 +1301,7 @@ Type *CParser_GetWCharType(void) {
short CParser_GetOperator(ENodeType t) {
switch (t) {
default:
-#line 1748
- CError_FATAL();
+ CError_FATAL(1748);
case EMONMIN: return '-';
case EBINNOT: return '~';
case ELOGNOT: return '!';
@@ -1757,7 +1721,7 @@ Boolean CParserIsVolatileExpr(ENode *expr) {
return CParser_IsVolatile(expr->rtype, expr->flags & ENODE_FLAG_QUALS);
}
-Boolean CParser_HasInternalLinkage(Object *obj) {
+Boolean CParser_HasInternalLinkage(const Object *obj) {
NameSpace *nspace;
for (nspace = obj->nspace; nspace; nspace = nspace->parent) {
@@ -1769,24 +1733,26 @@ Boolean CParser_HasInternalLinkage(Object *obj) {
return 1;
if (obj->qual & (Q_20000 | Q_OVERLOAD))
return 0;
- if (obj->sclass == OBJECT_SCLASS_102)
+ if (obj->sclass == TK_STATIC)
return 1;
+ // this feels *wrong* but it's the only way to match this function that I can see
if (obj->qual & Q_INLINE)
- obj->qual |= Q_20000;
+ ((Object *) obj)->qual |= Q_20000;
return 0;
}
-Boolean CParser_HasInternalLinkage2(Object *obj) {
+Boolean CParser_HasInternalLinkage2(const Object *obj) {
if (obj->datatype == DLOCAL)
return 1;
if (obj->qual & (Q_20000 | Q_OVERLOAD))
return 0;
- if (obj->sclass == OBJECT_SCLASS_102)
+ if (obj->sclass == TK_STATIC)
return 1;
+ // this feels *wrong* but it's the only way to match this function that I can see
if (obj->qual & Q_INLINE)
- obj->qual |= Q_20000;
+ ((Object *) obj)->qual |= Q_20000;
return 0;
}
@@ -2036,8 +2002,7 @@ void CParser_ParseAttribute(Type *type, DeclInfo *declinfo) {
declinfo->qual |= Q_ALIGNED_8192;
break;
default:
-#line 2779
- CError_FATAL();
+ CError_FATAL(2779);
break;
}
} else {
@@ -2638,10 +2603,10 @@ void CParser_GetDeclSpecs(DeclInfo *di, Boolean flag) {
SInt32 state;
CScopeParseResult pr;
- di->fileoffsetinfo.file = CPrep_BrowserCurrentFile();
+ di->file = CPrep_BrowserCurrentFile();
CPrep_BrowserFilePosition(
- (CPrepFileInfo **) &di->fileoffsetinfo.tokenline,
- &di->fileoffsetinfo.tokenoffset);
+ (CPrepFileInfo **) &di->file2,
+ &di->x60);
r24 = 1;
r23 = copts.cplusplus;
@@ -2940,8 +2905,7 @@ restart:
pr.x8 = TYPE(&stsignedint);
break;
default:
-#line 4109
- CError_FATAL();
+ CError_FATAL(4109);
}
break;
case TEMPLDEP_QUALNAME:
@@ -2954,8 +2918,7 @@ restart:
case TEMPLDEP_BITFIELD:
break;
default:
-#line 4136
- CError_FATAL();
+ CError_FATAL(4136);
}
}
@@ -2980,7 +2943,7 @@ restart:
typetoken = -1;
tk = lex();
if (tk == '<' && copts.objective_c && IS_TYPE_CLASS(di->thetype) && TYPE_CLASS(di->thetype)->objcinfo)
- di->thetype = CObjC_ParseTypeProtocol(di->thetype);
+ di->thetype = CObjC_ParseTypeProtocol(TYPE_CLASS(di->thetype));
goto bailOut;
} else if (pr.nsol_14) {
if (pr.x1D) {
@@ -3010,8 +2973,7 @@ restart:
CError_Error(121);
break;
default:
-#line 4217
- CError_FATAL();
+ CError_FATAL(4217);
}
} else if (pr.name_4) {
if (copts.cplusplus)
@@ -3022,8 +2984,7 @@ restart:
tk = lex();
r23 = 0;
} else {
-#line 4234
- CError_FATAL();
+ CError_FATAL(4234);
}
}
}
@@ -3216,8 +3177,7 @@ void CParser_CallBackAction(Object *obj) {
}
}
-#line 4551
- CError_FATAL();
+ CError_FATAL(4551);
}
static Object *CParser_FindOverloadFunc(NameSpaceObjectList *list, TypeFunc *tfunc) {
diff --git a/compiler_and_linker/unsorted/CPrec.c b/compiler_and_linker/unsorted/CPrec.c
index f835c6c..6e0692b 100644
--- a/compiler_and_linker/unsorted/CPrec.c
+++ b/compiler_and_linker/unsorted/CPrec.c
@@ -1,6 +1,17 @@
-#include "compiler.h"
-#include "compiler/CompilerTools.h"
+#include "compiler/CPrec.h"
#include "compiler/CError.h"
+#include "compiler/CFunc.h"
+#include "compiler/CInit.h"
+#include "compiler/CInline.h"
+#include "compiler/CMachine.h"
+#include "compiler/CObjC.h"
+#include "compiler/CParser.h"
+#include "compiler/CPrep.h"
+#include "compiler/CScope.h"
+#include "compiler/CSOM.h"
+#include "compiler/CTemplateNew.h"
+#include "compiler/CompilerTools.h"
+#include "compiler/Exceptions.h"
#include "compiler/enode.h"
#include "compiler/objc.h"
#include "compiler/objects.h"
@@ -9,84 +20,90 @@
#include "compiler/templates.h"
#include "compiler/types.h"
#include "cos.h"
-
-// HACKS
-extern Type stvoid;
-extern Type stbool;
-extern Type stchar;
-extern Type stsignedchar;
-extern Type stunsignedchar;
-extern Type stwchar;
-extern Type stsignedshort;
-extern Type stunsignedshort;
-extern Type stsignedint;
-extern Type stunsignedint;
-extern Type stsignedlong;
-extern Type stunsignedlong;
-extern Type stsignedlonglong;
-extern Type stunsignedlonglong;
-extern Type stfloat;
-extern Type stshortdouble;
-extern Type stdouble;
-extern Type stlongdouble;
-extern Type elipsis;
-extern Type oldstyle;
-extern Type stillegal;
-extern Type sttemplexpr;
-extern Type stvoid;
-extern Type void_ptr;
-extern Type rt_func;
-extern Type catchinfostruct;
-extern void * newh_func;
-extern void * delh_func;
-extern void * copy_func;
-extern void * clear_func;
-extern void * Rgtid_func;
-extern void * Rdync_func;
-extern void * rt_ptmf_cast;
-extern void * rt_ptmf_cmpr;
-extern void * rt_ptmf_test;
-extern void * rt_ptmf_call;
-extern void * rt_ptmf_scall;
-extern void * rt_ptmf_null;
-extern void * rt_som_glue1;
-extern void * rt_som_glue2;
-extern void * rt_som_glue3;
-extern void * rt_som_check;
-extern void * rt_som_new;
-extern void * rt_som_newcheck;
-extern void * rt_ptmf_call4;
-extern void * rt_ptmf_scall4;
-extern void * carr_func;
-extern void * cnar_func;
-extern void * darr_func;
-extern void * dnar_func;
-extern void * dnar3_func;
-extern void * Xgreg_func;
-extern void * Xthrw_func;
-extern void * Xicth_func;
-extern void * Xecth_func;
-extern void * Xunex_func;
-extern Type stvectorunsignedchar;
-extern Type stvectorsignedchar;
-extern Type stvectorboolchar;
-extern Type stvectorunsignedshort;
-extern Type stvectorsignedshort;
-extern Type stvectorboolshort;
-extern Type stvectorunsignedlong;
-extern Type stvectorsignedlong;
-extern Type stvectorboollong;
-extern Type stvectorfloat;
-extern Type stvectorpixel;
-// HACKS
-
-// PUBLIC FUNCTIONS
-extern void SetupPrecompiler();
-extern void CleanupPrecompiler();
-extern void PreComp_StaticData(Object *obj, const void *data, void *unk1, void *unk2);
-extern void PrecompilerWrite();
-extern void PrecompilerRead(short refnum, void *buffer);
-// END PUBLIC FUNCTIONS
+#include "compiler/CCompiler.h"
+#include "compiler/InlineAsm.h"
+
+#define RESOLVE_BUFFER(offset) ((void *) (((char *) cprec_buffer) + ((uintptr_t) (offset))))
+#define RESOLVE_RAW_BUFFER(offset) ((void *) (((char *) cprec_rawbuffer) + ((uintptr_t) (offset))))
+#define RESOLVE_SAFE(offset) (!(offset) ? NULL : ((void *) (((char *) cprec_rawbuffer) + ((uintptr_t) (offset)))))
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+typedef struct StaticData {
+ struct StaticData *next;
+ Object *object;
+ void *buffer;
+ OLinkList *links;
+ SInt32 size;
+} StaticData;
+
+typedef struct Header {
+ UInt32 magic;
+ UInt16 version;
+ UInt16 x6;
+ char target;
+ Boolean check_header_flags;
+ Boolean cplusplus;
+ UInt32 xC;
+ UInt32 x10;
+ UInt32 x14;
+ UInt32 x18;
+ UInt32 x1C;
+ UInt32 x20;
+ UInt32 x24;
+ UInt32 x28;
+ UInt32 x2C;
+ UInt32 x30;
+ UInt32 compressedPatchCount;
+ UInt32 compressedPatchSize;
+ UInt32 compressedPatchOffset;
+ UInt32 builtinPatchSize;
+ UInt32 builtinPatchOffset;
+ UInt32 tokenStreamPatchSize;
+ UInt32 tokenStreamPatchOffset;
+ UInt32 root_names;
+ NameSpaceList *usings;
+ TemplClass *ctempl_templates;
+ CSOMStub *csom_stubs;
+ StaticData *cprec_staticdata;
+ UInt32 uniqueID;
+ CallbackAction *callbackactions;
+ Type *cobjc_type_class;
+ Type *cobjc_type_id;
+ Type *cobjc_type_sel;
+ ObjCSelector **cobjc_selhashtable;
+ BClassList *cobjc_classdefs;
+ ObjCProtocol *cobjc_protocols;
+ UInt32 cobjc_selrefcount;
+ UInt32 cobjc_classrefcount;
+ UInt32 cobjc_stringcount;
+ InitExpr *init_expressions;
+ CI_Action *cinline_tactionlist;
+ TemplateFunction *ctempl_templatefuncs;
+ UInt32 x9C;
+ UInt32 xA0;
+ UInt32 xA4;
+ UInt32 xA8;
+ UInt32 xAC;
+ UInt32 xB0;
+ UInt32 xB4;
+ UInt32 xB8;
+ UInt32 xBC;
+ UInt32 xC0;
+ UInt32 xC4;
+ UInt32 xC8;
+ UInt32 xCC;
+ UInt32 xD0;
+ UInt32 xD4;
+ UInt32 xD8;
+ UInt32 xDC;
+ UInt32 xE0;
+ UInt32 xE4;
+ HashNameNode *nametable[0x800];
+ Macro *macrotable[0x800];
+ NameSpaceName *root_nametable[0x400];
+} Header;
typedef struct Patch {
struct Patch *next;
@@ -121,31 +138,41 @@ typedef struct TokenPatch {
SInt32 count;
} TokenPatch;
static TokenPatch *cprec_tokenpatches;
+static StaticData *cprec_staticdata;
+
+typedef struct PointerHash {
+ struct PointerHash *next;
+ TypePointer *tptr;
+ TypePointer *prec_tptr;
+} PointerHash;
+static PointerHash **cprec_pointerhash;
-static void *cprec_staticdata;
-static void *cprec_pointerhash;
static BuiltIn *cprec_builtin;
static Patch *cprec_patch_list;
static AddrPatch **cprec_addrhash;
-static void *cprec_header;
+static Header *cprec_header;
static GList cprec_glist;
static short cprec_refnum;
char *precomp_target_str;
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
// Assorted forward declarations
static NameSpace *CPrec_GetNameSpacePatch(NameSpace *nspace);
static ObjEnumConst *CPrec_GetObjEnumConstPatch(ObjEnumConst *obj);
static Object *CPrec_GetObjectPatch(Object *obj);
static ObjBase *CPrec_GetObjBasePatch(ObjBase *obj);
-static ObjMemberVar *CPrec_GetObjMemberVarPatch(ObjMemberVar *obj);
+static ObjMemberVar *CPrec_GetObjMemberVarPatch(ObjMemberVar *ivar);
static Type *CPrec_GetTypePatch(Type *type);
-static ENode *CPrec_GetExpressionPatch(ENode *enode);
+static ENode *CPrec_GetExpressionPatch(ENode *expr);
static ObjCMethod *CPrec_GetObjCMethodPatch(ObjCMethod *meth);
static ObjCProtocolList *CPrec_GetObjCProtocolListPatch(ObjCProtocolList *lst);
static TemplArg *CPrec_GetTemplateArgPatch(TemplArg *arg);
-static OSErr CPrec_FlushBufferCheck();
+static NameSpaceObjectList *CPrec_GetNameSpaceObjectListPatch(NameSpaceObjectList *nsol);
+static OSErr CPrec_FlushBufferCheck(void);
-void SetupPrecompiler() {
+void SetupPrecompiler(void) {
cprec_refnum = 0;
cprec_glist.data = NULL;
cprec_header = NULL;
@@ -153,7 +180,7 @@ void SetupPrecompiler() {
cprec_ioerror = noErr;
}
-void CleanupPrecompiler() {
+void CleanupPrecompiler(void) {
if (cprec_refnum) {
COS_FileClose(cprec_refnum);
cprec_refnum = 0;
@@ -163,20 +190,49 @@ void CleanupPrecompiler() {
FreeGList(&cprec_glist);
}
-static void CPrec_OLinkListCopy() {}
+static OLinkList *CPrec_OLinkListCopy(OLinkList *list) {
+ OLinkList *copy;
+
+ if (!list)
+ return NULL;
+
+ copy = galloc(sizeof(OLinkList));
+ *copy = *list;
+ copy->next = CPrec_OLinkListCopy(copy->next);
+ return copy;
+}
+
+void PreComp_StaticData(Object *obj, const void *data, OLinkList *links, SInt32 size) {
+ StaticData *entry;
-void PreComp_StaticData(Object *obj, const void *data, void *unk1, void *unk2) {
+ if (obj->sclass != TK_STATIC && !(obj->qual & (Q_20000 | Q_OVERLOAD)))
+ CError_Error(CErrorStr180);
+ entry = galloc(sizeof(StaticData));
+ entry->object = obj;
+ entry->size = size;
+
+ entry->next = cprec_staticdata;
+ cprec_staticdata = entry;
+
+ if (data) {
+ entry->buffer = galloc(obj->type->size);
+ memcpy(entry->buffer, data, obj->type->size);
+ } else {
+ entry->buffer = NULL;
+ }
+
+ entry->links = CPrec_OLinkListCopy(links);
}
-static void CPrec_InitAddressHashTable() {
+static void CPrec_InitAddressHashTable(void) {
cprec_addrhash = lalloc(0x4000 * sizeof(AddrPatch *));
memclrw(cprec_addrhash, 0x4000 * sizeof(AddrPatch *));
}
-static void CPrec_InitPointerHashTable() {
- cprec_pointerhash = lalloc(0x1000);
- memclrw(cprec_pointerhash, 0x1000);
+static void CPrec_InitPointerHashTable(void) {
+ cprec_pointerhash = lalloc(0x400 * sizeof(PointerHash *));
+ memclrw(cprec_pointerhash, 0x400 * sizeof(PointerHash *));
}
static int CPrec_AddressHashVal(void *addr) {
@@ -214,7 +270,7 @@ static AddrPatch *CPrec_NewAddrPatch(void *addr, void *value) {
return patch;
}
-static void CPrec_SetupBuiltInArray() {
+static void CPrec_SetupBuiltInArray(void) {
int count1, count2;
Boolean flag;
void **array;
@@ -303,7 +359,7 @@ static void CPrec_SetupBuiltInArray() {
}
}
-static void CPrec_SetupBuiltIn() {
+static void CPrec_SetupBuiltIn(void) {
int x;
CPrec_SetupBuiltInArray();
@@ -321,13 +377,11 @@ static void CPrec_NewPointerPatch(void *src, void *ptr) {
if (cprec_dowrite) {
Patch *patch = lalloc(sizeof(Patch));
patch->offset = (SInt32) src;
-#line 507
- CError_ASSERT((patch->offset & 0x80000001) == 0);
+ CError_ASSERT(507, (patch->offset & 0x80000001) == 0);
if ((SInt32) ptr < 0) {
ptr = (void *) ~((SInt32) ptr);
-#line 513
- CError_ASSERT((SInt32) ptr < cprec_builtins);
+ CError_ASSERT(513, (SInt32) ptr < cprec_builtins);
patch->next = cprec_builtin[(SInt32) ptr].patches;
cprec_builtin[(SInt32) ptr].patches = patch;
@@ -338,8 +392,7 @@ static void CPrec_NewPointerPatch(void *src, void *ptr) {
}
src = (void *)((char *) src - cprec_zero_offset);
-#line 525
- CError_ASSERT((SInt32) src >= 0 && (SInt32) src <= cprec_glist.size);
+ CError_ASSERT(525, (SInt32) src >= 0 && (SInt32) src <= cprec_glist.size);
*((void **) (*cprec_glist.data + (SInt32) src)) = ptr;
}
}
@@ -349,21 +402,17 @@ static void CPrec_ExistingPointerPatch(void *src, void *ptr) {
AddrPatch *addrPatch;
Patch *patch;
- addrPatch = CPrec_FindAddrPatch(ptr);
-#line 543
- CError_ASSERT(addrPatch);
+ CError_ASSERT(543, addrPatch = CPrec_FindAddrPatch(ptr));
patch = lalloc(sizeof(Patch));
patch->offset = (SInt32) src;
patch->next = cprec_patch_list;
cprec_patch_list = patch;
-#line 548
- CError_ASSERT((patch->offset & 0x80000001) == 0);
+ CError_ASSERT(548, (patch->offset & 0x80000001) == 0);
src = (void *)((char *) src - cprec_zero_offset);
-#line 552
- CError_ASSERT((SInt32) src >= 0 && (SInt32) src <= cprec_glist.size);
+ CError_ASSERT(552, (SInt32) src >= 0 && (SInt32) src <= cprec_glist.size);
*((void **) (*cprec_glist.data + (SInt32) src)) = addrPatch->value;
}
}
@@ -373,7 +422,7 @@ static void CPrec_NamePatch(void *src, HashNameNode *name) {
CPrec_ExistingPointerPatch(src, name);
}
-static void *CPrec_AppendAlign() {
+static void *CPrec_AppendAlign(void) {
if (cprec_dowrite) {
while (cprec_offset & 3) {
AppendGListByte(&cprec_glist, 0);
@@ -421,17 +470,14 @@ static UInt32 CPrec_AppendPointerPatch(void *v) {
AddrPatch *addrPatch;
if (v) {
- addrPatch = CPrec_FindAddrPatch(v);
-#line 644
- CError_ASSERT(addrPatch);
+ CError_ASSERT(644, addrPatch = CPrec_FindAddrPatch(v));
if (cprec_dowrite) {
Patch *patch = lalloc(sizeof(Patch));
patch->offset = cprec_offset;
patch->next = cprec_patch_list;
cprec_patch_list = patch;
-#line 651
- CError_ASSERT((patch->offset & 0x80000001) == 0);
+ CError_ASSERT(651, (patch->offset & 0x80000001) == 0);
}
return CPrec_AppendPointer(addrPatch->value);
@@ -466,9 +512,141 @@ static void CPrec_RawMemPatch(void *source, const void *data, int len) {
CPrec_NewPointerPatch(source, ptr);
}
-static void CPrec_DumpNameTable() {}
-static void CPrec_DumpMacroTable() {}
-static void CPrec_GetClassAccessPatch() {}
+static void CPrec_DumpNameTable(void) {
+ HashNameNode *name;
+ int i;
+ HashNameNode *p;
+ HashNameNode *next;
+
+ if (cprec_dowrite) {
+ i = 0;
+ do {
+ name = name_hash_nodes[i];
+ while (name && name->id == 0)
+ name = name->next;
+
+ if (name) {
+ p = CPrec_AppendAlign();
+ cprec_header->nametable[i] = p;
+
+ while (1) {
+ CPrec_NewAddrPatch(name, p);
+ CPrec_AppendPointer(NULL);
+ CPrec_AppendWord32(0);
+ CPrec_AppendWord16(name->hashval);
+ CPrec_AppendString(name->name);
+
+ name = name->next;
+ while (name && name->id == 0)
+ name = name->next;
+
+ if (!name)
+ break;
+
+ next = CPrec_AppendAlign();
+ CPrec_NewPointerPatch(&p->next, next);
+ p = next;
+ }
+ }
+ } while (++i < 0x800);
+ } else {
+ i = 0;
+ do {
+ if ((name = name_hash_nodes[i])) {
+ p = CPrec_AppendAlign();
+ while (1) {
+ CPrec_NewAddrPatch(name, p);
+ CPrec_AppendPointer(NULL);
+ CPrec_AppendWord32(0);
+ CPrec_AppendWord16(name->hashval);
+ CPrec_AppendString(name->name);
+
+ name = name->next;
+ if (!name)
+ break;
+
+ next = CPrec_AppendAlign();
+ CPrec_NewPointerPatch(&p->next, next);
+ p = next;
+ }
+ }
+ } while (++i < 0x800);
+ }
+}
+
+static void CPrec_DumpMacroTable(void) {
+ Macro *macro;
+ int i;
+ int j;
+ Macro *p;
+ Macro *next;
+
+ i = 0;
+ do {
+ for (macro = macrohashtable[i]; macro; macro = macro->next) {
+ if (macro->c) {
+ CPrec_NewAddrPatch(macro->c, (void *) cprec_offset);
+ CPrec_AppendString(macro->c);
+ }
+ }
+ } while (++i < 0x800);
+
+ i = 0;
+ do {
+ macro = macrohashtable[i];
+
+ if (macro) {
+ p = CPrec_AppendAlign();
+ if (cprec_dowrite)
+ cprec_header->macrotable[i] = p;
+
+ while (1) {
+ CPrec_AppendPointer(NULL);
+ CPrec_AppendNamePatch(macro->name);
+ CPrec_AppendPointerPatch(macro->c);
+ CPrec_AppendWord16(macro->xC);
+ CPrec_AppendByte(macro->is_special);
+ CPrec_AppendByte(macro->xF);
+
+ for (j = 1; j < (macro->xC & 0x7FFF); j++)
+ CPrec_AppendNamePatch(macro->names[j - 1]);
+
+ macro = macro->next;
+ if (!macro)
+ break;
+
+ next = CPrec_AppendAlign();
+ CPrec_NewPointerPatch(&p->next, next);
+ p = next;
+ }
+ }
+ } while (++i < 0x800);
+}
+
+static BClassList *CPrec_GetClassAccessPatch(BClassList *path) {
+ AddrPatch *addrPatch;
+ BClassList *first, *current, *next;
+
+ if ((addrPatch = CPrec_FindAddrPatch(path)))
+ return addrPatch->value;
+
+ first = current = CPrec_AppendAlign();
+ CPrec_NewAddrPatch(path, first);
+
+ while (1) {
+ CPrec_AppendData(path, sizeof(BClassList));
+ CPrec_NewPointerPatch(¤t->type, CPrec_GetTypePatch(path->type));
+ if (!path->next)
+ break;
+
+ next = CPrec_AppendAlign();
+ CPrec_NewPointerPatch(¤t->next, next);
+ current = next;
+ path = path->next;
+ }
+
+ return first;
+}
static int CPrec_PointerHash(TypePointer *type) {
Type *target;
@@ -517,8 +695,54 @@ restart:
return (work + (work >> 24) + (work >> 16) + (work >> 8)) & 0x3FF;
}
-static TypePointer *CPrec_GetTypePointerPatch(TypePointer *type) {
- // requires copts
+static TypePointer *CPrec_GetTypePointerPatch(TypePointer *tptr) {
+ TypePointer *p;
+ int hash;
+ PointerHash *phash;
+ TypePointer *scan1;
+ TypePointer *scan2;
+
+ if (tptr->qual & Q_100000) {
+ p = CPrec_AppendAlign();
+ CPrec_NewAddrPatch(tptr, p);
+ CPrec_AppendData(tptr, sizeof(TypeObjCID));
+ if (TYPE_OBJC_ID(tptr)->protocols)
+ CPrec_NewPointerPatch(&TYPE_OBJC_ID(p)->protocols, CPrec_GetObjCProtocolListPatch(TYPE_OBJC_ID(tptr)->protocols));
+ } else {
+ if (!copts.faster_pch_gen && cprec_dowrite && tptr->size > 0) {
+ hash = CPrec_PointerHash(tptr);
+ for (phash = cprec_pointerhash[hash]; phash; phash = phash->next) {
+ scan1 = tptr;
+ scan2 = phash->tptr;
+ check_again:
+ if (scan1->type == scan2->type && scan1->size == scan2->size && scan1->qual == scan2->qual) {
+ scan1 = TYPE_POINTER(TPTR_TARGET(scan1));
+ scan2 = TYPE_POINTER(TPTR_TARGET(scan2));
+ if (scan1->type == TYPEPOINTER && scan1->type == TYPEARRAY)
+ goto check_again;
+ if (scan1 == scan2)
+ return phash->prec_tptr;
+ }
+ }
+
+ p = CPrec_AppendAlign();
+ CPrec_NewAddrPatch(tptr, p);
+
+ phash = lalloc(sizeof(PointerHash));
+ phash->tptr = tptr;
+ phash->prec_tptr = p;
+ phash->next = cprec_pointerhash[hash];
+ cprec_pointerhash[hash] = phash;
+ } else {
+ p = CPrec_AppendAlign();
+ CPrec_NewAddrPatch(tptr, p);
+ }
+
+ CPrec_AppendData(tptr, sizeof(TypePointer));
+ }
+
+ CPrec_NewPointerPatch(&p->target, CPrec_GetTypePatch(tptr->target));
+ return p;
}
static TypeEnum *CPrec_GetTypeEnumPatch(TypeEnum *type) {
@@ -541,15 +765,48 @@ static TypeEnum *CPrec_GetTypeEnumPatch(TypeEnum *type) {
static TypeBitfield *CPrec_GetTypeBitfieldPatch(TypeBitfield *type) {
TypeBitfield *p = CPrec_AppendAlign();
+
CPrec_NewAddrPatch(type, p);
CPrec_AppendData(type, sizeof(TypeBitfield));
-
- CPrec_NewPointerPatch(&p->bitfieldtype, type->bitfieldtype);
+ CPrec_NewPointerPatch(&p->bitfieldtype, CPrec_GetTypePatch(type->bitfieldtype));
return p;
}
-static TypeStruct *CPrec_GetTypeStructPatch(TypeStruct *type) {}
+static TypeStruct *CPrec_GetTypeStructPatch(TypeStruct *tstruct) {
+ StructMember *member;
+ TypeStruct *p;
+ StructMember *current, *next;
+
+ p = CPrec_AppendAlign();
+ CPrec_NewAddrPatch(tstruct, p);
+ CPrec_AppendData(tstruct, sizeof(TypeStruct));
+
+ if (tstruct->name)
+ CPrec_NamePatch(&p->name, tstruct->name);
+
+ if ((member = tstruct->members)) {
+ current = CPrec_AppendAlign();
+ CPrec_NewPointerPatch(&p->members, current);
+
+ while (1) {
+ CPrec_AppendData(member, sizeof(StructMember));
+ CPrec_NewPointerPatch(¤t->type, CPrec_GetTypePatch(member->type));
+ CPrec_NamePatch(¤t->name, member->name);
+
+ if (!member->next)
+ break;
+
+ next = CPrec_AppendAlign();
+ CPrec_NewPointerPatch(¤t->next, next);
+ current = next;
+
+ member = member->next;
+ }
+ }
+
+ return p;
+}
static ExceptSpecList *CPrec_GetExceptSpecPatch(ExceptSpecList *exspec) {
ExceptSpecList *first, *current, *next;
@@ -572,40 +829,40 @@ static ExceptSpecList *CPrec_GetExceptSpecPatch(ExceptSpecList *exspec) {
}
static FuncArg *CPrec_GetArgListPatch(FuncArg *lst, Boolean includeNames) {
- // too many register swaps
- AddrPatch *addrPatch;
FuncArg *first, *current, *next;
+ AddrPatch *addrPatch;
if ((addrPatch = CPrec_FindAddrPatch(lst)))
return addrPatch->value;
first = current = CPrec_AppendAlign();
-restart:
- if (!includeNames)
- lst->name = NULL;
- CPrec_AppendData(lst, sizeof(FuncArg));
- if (includeNames && lst->name)
- CPrec_NamePatch(¤t->name, lst->name);
-
- if (lst->dexpr)
- CPrec_NewPointerPatch(¤t->dexpr, CPrec_GetExpressionPatch(lst->dexpr));
- if (lst->type)
- CPrec_NewPointerPatch(¤t->type, CPrec_GetTypePatch(lst->type));
- else
-#line 1167
- CError_FATAL();
+ while (1) {
+ if (!includeNames)
+ lst->name = NULL;
+ CPrec_AppendData(lst, sizeof(FuncArg));
+ if (includeNames && lst->name)
+ CPrec_NamePatch(¤t->name, lst->name);
+
+ if (lst->dexpr)
+ CPrec_NewPointerPatch(¤t->dexpr, CPrec_GetExpressionPatch(lst->dexpr));
+ if (lst->type)
+ CPrec_NewPointerPatch(¤t->type, CPrec_GetTypePatch(lst->type));
+ else
+ CError_FATAL(1167);
+
+ if (!lst->next)
+ break;
- if (lst->next) {
if ((addrPatch = CPrec_FindAddrPatch(lst->next))) {
CPrec_NewPointerPatch(¤t->next, addrPatch->value);
- } else {
- next = CPrec_AppendAlign();
- CPrec_NewPointerPatch(¤t->next, next);
- current = next;
- lst = lst->next;
- CPrec_NewAddrPatch(lst, next);
- goto restart;
+ break;
}
+
+ next = CPrec_AppendAlign();
+ CPrec_NewPointerPatch(¤t->next, next);
+ current = next;
+ lst = lst->next;
+ CPrec_NewAddrPatch(lst, next);
}
return first;
@@ -670,8 +927,7 @@ static TypeTemplDep *CPrec_GetTypeTemplDepPatch(TypeTemplDep *type) {
CPrec_NewPointerPatch(&p->u.bitfield.size, CPrec_GetExpressionPatch(type->u.bitfield.size));
break;
default:
-#line 1295
- CError_FATAL();
+ CError_FATAL(1295);
}
return p;
@@ -817,7 +1073,7 @@ static ObjCMethodArg *CPrec_GetObjCMethodArgPatch(ObjCMethodArg *arg) {
first = current = CPrec_AppendAlign();
do {
- CPrec_AppendData(arg, sizeof(ObjCMethodArg));
+ CPrec_AppendData(arg, sizeof(ObjCMethod));
if (arg->selector)
CPrec_NamePatch(¤t->selector, arg->selector);
if (arg->name)
@@ -1087,8 +1343,7 @@ static TemplArg *CPrec_GetTemplateArgPatch(TemplArg *arg) {
CPrec_NewPointerPatch(¤t->data.ttargtype, CPrec_GetTypePatch(arg->data.ttargtype));
break;
default:
-#line 1879
- CError_FATAL();
+ CError_FATAL(1879);
}
if (!arg->next)
@@ -1125,12 +1380,10 @@ static TemplParam *CPrec_GetTemplateParamPatch(TemplParam *param) {
case TPT_TEMPLATE:
if (param->data.templparam.plist)
CPrec_NewPointerPatch(¤t->data.templparam.plist, CPrec_GetTemplateParamPatch(param->data.templparam.plist));
-#line 1953
- CError_ASSERT(!param->data.templparam.defaultarg);
+ CError_ASSERT(1953, !param->data.templparam.defaultarg);
break;
default:
-#line 1958
- CError_FATAL();
+ CError_FATAL(1958);
}
if (!param->next)
@@ -1206,8 +1459,7 @@ static TStreamElement *CPrec_GetTStreamPatch(TStreamElement *tokens, SInt32 coun
break;
default:
if (tokens->tokentype < 0)
-#line 2063
- CError_FATAL();
+ CError_FATAL(2063);
}
x++;
tokens++;
@@ -1361,8 +1613,7 @@ static TemplateAction *CPrec_GetTemplateActionPatch(TemplateAction *act) {
CPrec_NewPointerPatch(¤t->u.refobj, CPrec_GetObjBasePatch(act->u.refobj));
break;
default:
-#line 2410
- CError_FATAL();
+ CError_FATAL(2410);
}
if (!act->next)
@@ -1549,8 +1800,7 @@ static Type *CPrec_GetTypePatch(Type *type) {
case TYPEOBJCID:
case TYPETEMPLDEPEXPR:
default:
-#line 2796
- CError_FATAL();
+ CError_FATAL(2796);
return NULL;
}
}
@@ -1619,8 +1869,7 @@ repeat:
case EAT_TERMINATE:
break;
default:
-#line 2905
- CError_FATAL();
+ CError_FATAL(2905);
}
if (exc->prev) {
@@ -1652,17 +1901,247 @@ static ENodeList *CPrec_GetExpressionListPatch(ENodeList *lst) {
return first;
}
-static void CPrec_GetEMemberInfoPatch() {}
+static EMemberInfo *CPrec_GetEMemberInfoPatch(EMemberInfo *emember) {
+ EMemberInfo *p;
+
+ CError_FATAL(2953);
+
+ p = CPrec_AppendAlign();
+ CPrec_AppendData(emember, sizeof(EMemberInfo));
+
+ if (emember->path)
+ CPrec_NewPointerPatch(&p->path, CPrec_GetClassAccessPatch(emember->path));
+ if (emember->expr)
+ CPrec_NewPointerPatch(&p->expr, CPrec_GetExpressionPatch(emember->expr));
+ CError_ASSERT(2968, !emember->templargs);
+ CPrec_NewPointerPatch(&p->list, CPrec_GetNameSpaceObjectListPatch(emember->list));
+
+ return p;
+}
+
+static ENode *CPrec_GetExpressionPatch(ENode *expr) {
+ ENode *p;
+
+ if (ENODE_IS(expr, ETEMPLDEP) && expr->data.templdep.subtype == TDE_SOURCEREF)
+ expr->data.templdep.u.sourceref.token = NULL;
+
+ p = CPrec_AppendAlign();
+ CPrec_AppendData(expr, sizeof(ENode));
+
+ CPrec_NewPointerPatch(&p->rtype, CPrec_GetTypePatch(expr->rtype));
+
+ switch (expr->type) {
+ ENODE_CASE_MONADIC:
+ CPrec_NewPointerPatch(&p->data.monadic, CPrec_GetExpressionPatch(expr->data.monadic));
+ break;
+ ENODE_CASE_DIADIC_ALL:
+ CPrec_NewPointerPatch(&p->data.diadic.left, CPrec_GetExpressionPatch(expr->data.diadic.left));
+ CPrec_NewPointerPatch(&p->data.diadic.right, CPrec_GetExpressionPatch(expr->data.diadic.right));
+ break;
+ case ECOND:
+ CPrec_NewPointerPatch(&p->data.cond.cond, CPrec_GetExpressionPatch(expr->data.cond.cond));
+ CPrec_NewPointerPatch(&p->data.cond.expr1, CPrec_GetExpressionPatch(expr->data.cond.expr1));
+ CPrec_NewPointerPatch(&p->data.cond.expr2, CPrec_GetExpressionPatch(expr->data.cond.expr2));
+ break;
+ case ESTRINGCONST:
+ CPrec_RawMemPatch(&p->data.string.data, expr->data.string.data, expr->data.string.size);
+ break;
+ case EOBJREF:
+ CPrec_NewPointerPatch(&p->data.objref, CPrec_GetObjectPatch(expr->data.objref));
+ break;
+ case EOBJLIST:
+ CPrec_NewPointerPatch(&p->data.objlist.list, CPrec_GetNameSpaceObjectListPatch(expr->data.objlist.list));
+ CError_ASSERT(3043, !expr->data.objlist.templargs);
+ if (expr->data.objlist.name)
+ CPrec_NamePatch(&p->data.objlist.name, expr->data.objlist.name);
+ break;
+ case EMFPOINTER:
+ CPrec_NewPointerPatch(&p->data.mfpointer.accessnode, CPrec_GetExpressionPatch(expr->data.mfpointer.accessnode));
+ CPrec_NewPointerPatch(&p->data.mfpointer.mfpointer, CPrec_GetExpressionPatch(expr->data.mfpointer.mfpointer));
+ break;
+ case ENULLCHECK:
+ CPrec_NewPointerPatch(&p->data.nullcheck.nullcheckexpr, CPrec_GetExpressionPatch(expr->data.nullcheck.nullcheckexpr));
+ CPrec_NewPointerPatch(&p->data.nullcheck.condexpr, CPrec_GetExpressionPatch(expr->data.nullcheck.condexpr));
+ break;
+ case ETEMP:
+ CPrec_NewPointerPatch(&p->data.temp.type, CPrec_GetTypePatch(expr->data.temp.type));
+ break;
+ case EFUNCCALL:
+ case EFUNCCALLP:
+ CPrec_NewPointerPatch(&p->data.funccall.funcref, CPrec_GetExpressionPatch(expr->data.funccall.funcref));
+ CPrec_NewPointerPatch(&p->data.funccall.functype, CPrec_GetTypePatch(TYPE(expr->data.funccall.functype)));
+ if (expr->data.funccall.args)
+ CPrec_NewPointerPatch(&p->data.funccall.args, CPrec_GetExpressionListPatch(expr->data.funccall.args));
+ break;
+ case EMEMBER:
+ CPrec_NewPointerPatch(&p->data.emember, CPrec_GetEMemberInfoPatch(expr->data.emember));
+ break;
+ case ETEMPLDEP:
+ switch (expr->data.templdep.subtype) {
+ case TDE_PARAM:
+ break;
+ case TDE_SIZEOF:
+ case TDE_ALIGNOF:
+ CPrec_NewPointerPatch(&p->data.templdep.u.typeexpr.type, CPrec_GetTypePatch(expr->data.templdep.u.typeexpr.type));
+ break;
+ case TDE_CAST:
+ if (expr->data.templdep.u.cast.args)
+ CPrec_NewPointerPatch(&p->data.templdep.u.cast.args, CPrec_GetExpressionListPatch(expr->data.templdep.u.cast.args));
+ CPrec_NewPointerPatch(&p->data.templdep.u.cast.type, CPrec_GetTypePatch(expr->data.templdep.u.cast.type));
+ break;
+ case TDE_QUALNAME:
+ CPrec_NamePatch(&p->data.templdep.u.qual.name, expr->data.templdep.u.qual.name);
+ CPrec_NewPointerPatch(&p->data.templdep.u.qual.type, CPrec_GetTypePatch(TYPE(expr->data.templdep.u.qual.type)));
+ break;
+ case TDE_OBJ:
+ CPrec_NewPointerPatch(&p->data.templdep.u.obj, CPrec_GetObjectPatch(expr->data.templdep.u.obj));
+ break;
+ case TDE_SOURCEREF:
+ CPrec_NewPointerPatch(&p->data.templdep.u.sourceref.expr, CPrec_GetExpressionPatch(expr->data.templdep.u.sourceref.expr));
+ break;
+ case TDE_ADDRESS_OF:
+ CPrec_NewPointerPatch(&p->data.templdep.u.monadic, CPrec_GetExpressionPatch(expr->data.templdep.u.monadic));
+ break;
+ default:
+ CError_FATAL(3136);
+ }
+ break;
+ case EINTCONST:
+ case EFLOATCONST:
+ case EPRECOMP:
+ case EARGOBJ:
+ case ELOCOBJ:
+ case ELABEL:
+ case EINSTRUCTION:
+ case EVECTOR128CONST:
+ break;
+ default:
+ CError_FATAL(3142);
+ }
+
+ return p;
+}
+
+static CI_Switch *CPrec_GetSwitchInfoPatch(CI_Switch *si) {
+ CI_Switch *p = CPrec_AppendAlign();
+ CPrec_AppendData(si, sizeof(CI_Switch) + sizeof(CI_SwitchCase) * (si->numcases - 1));
+
+ CPrec_NewPointerPatch(&p->expr, CPrec_GetExpressionPatch(si->expr));
+ CPrec_NewPointerPatch(&p->unkSwitch8, CPrec_GetTypePatch(si->unkSwitch8));
+ return p;
+}
+
+static InlineAsm *CPrec_GetInlineAsmPatch(InlineAsm *ia, SInt32 size) {
+ InlineAsm *p;
+ SInt32 index;
+ SInt32 offset;
+ Object *object;
+
+ p = CPrec_AppendAlign();
+ CPrec_AppendData(ia, size);
+
+ index = 0;
+ while (1) {
+ object = InlineAsm_GetObjectOffset(ia, index, &offset);
+ if (!object)
+ break;
+
+ object = CPrec_GetObjectPatch(object);
+ CPrec_NewPointerPatch((char *) p + offset, object);
+ index++;
+ }
+
+ return p;
+}
+
+static CI_Statement *CPrec_GetStatementPatch(CI_Statement *stmt, short count) {
+ short i;
+ CI_Statement *first, *current;
+
+ for (i = 0; i < count; i++) {
+ stmt[i].sourcefilepath = NULL;
+ stmt[i].sourceoffset = -1;
+ }
+
+ first = current = CPrec_AppendAlign();
+ CPrec_AppendData(stmt, sizeof(CI_Statement) * count);
+
+ for (i = 0; i < count; i++) {
+ if (stmt->dobjstack)
+ CPrec_NewPointerPatch(¤t->dobjstack, CPrec_GetExceptionPatch(stmt->dobjstack));
+
+ switch (stmt->type) {
+ case ST_EXPRESSION:
+ case ST_RETURN:
+ case ST_BEGINCATCH:
+ case ST_ENDCATCH:
+ case ST_ENDCATCHDTOR:
+ if (stmt->u.expr)
+ CPrec_NewPointerPatch(¤t->u.expr, CPrec_GetExpressionPatch(stmt->u.expr));
+ break;
+ case ST_IFGOTO:
+ case ST_IFNGOTO:
+ CPrec_NewPointerPatch(¤t->u.ifgoto.expr, CPrec_GetExpressionPatch(stmt->u.ifgoto.expr));
+ break;
+ case ST_SWITCH:
+ CPrec_NewPointerPatch(¤t->u.switchdata, CPrec_GetSwitchInfoPatch(stmt->u.switchdata));
+ break;
+ case ST_ASM:
+ CPrec_NewPointerPatch(¤t->u.asmdata.data, CPrec_GetInlineAsmPatch(stmt->u.asmdata.data, stmt->u.asmdata.size));
+ break;
+ case ST_NOP:
+ case ST_LABEL:
+ case ST_GOTO:
+ break;
+ default:
+ CError_FATAL(3261);
+ }
+
+ current++;
+ stmt++;
+ }
+
+ return first;
+}
+
+static CI_Var *CPrec_GetLocObjectPatch(CI_Var *obj, short count) {
+ CI_Var *first, *current;
+ short i;
+
+ first = current = CPrec_AppendAlign();
+ CPrec_AppendData(obj, sizeof(CI_Var) * count);
-static ENode *CPrec_GetExpressionPatch(ENode *enode) {
+ for (i = 0; i < count; i++) {
+ CPrec_NamePatch(¤t->name, obj->name);
+ CPrec_NewPointerPatch(¤t->type, CPrec_GetTypePatch(obj->type));
+ current++;
+ obj++;
+ }
+ return first;
}
-static void CPrec_GetSwitchInfoPatch() {}
-static void CPrec_GetInlineAsmPatch() {}
-static void CPrec_GetStatementPatch() {}
-static void CPrec_GetLocObjectPatch() {}
-static void CPrec_GetInlineFuncPatch() {}
+static CI_FuncData *CPrec_GetInlineFuncPatch(CI_FuncData *ifunc) {
+ CI_FuncData *p;
+
+ memclrw(&ifunc->fileoffset, sizeof(FileOffsetInfo));
+ ifunc->symdecloffset = 0;
+ ifunc->functionbodyoffset = 0;
+ ifunc->functionbodypath = NULL;
+ ifunc->symdeclend = 0;
+
+ p = CPrec_AppendAlign();
+ CPrec_AppendData(ifunc, sizeof(CI_FuncData));
+
+ if (ifunc->numarguments)
+ CPrec_NewPointerPatch(&p->arguments, CPrec_GetLocObjectPatch(ifunc->arguments, ifunc->numarguments));
+ if (ifunc->numlocals)
+ CPrec_NewPointerPatch(&p->locals, CPrec_GetLocObjectPatch(ifunc->locals, ifunc->numlocals));
+ if (ifunc->numstatements)
+ CPrec_NewPointerPatch(&p->statements, CPrec_GetStatementPatch(ifunc->statements, ifunc->numstatements));
+
+ return p;
+}
static ObjEnumConst *CPrec_GetObjEnumConstPatch(ObjEnumConst *obj) {
AddrPatch *addrPatch;
@@ -1677,8 +2156,7 @@ static ObjEnumConst *CPrec_GetObjEnumConstPatch(ObjEnumConst *obj) {
do {
CPrec_AppendData(obj, sizeof(ObjEnumConst));
if (cprec_dowrite) {
-#line 3349
- CError_ASSERT(obj->access != 255);
+ CError_ASSERT(3349, obj->access != 255);
obj->access = 255;
}
CPrec_NamePatch(¤t->name, obj->name);
@@ -1744,8 +2222,48 @@ static ObjNameSpace *CPrec_GetObjNameSpacePatch(ObjNameSpace *obj) {
return p;
}
-static ObjMemberVar *CPrec_GetObjMemberVarPatch(ObjMemberVar *obj) {
+static ObjMemberVar *CPrec_GetObjMemberVarPatch(ObjMemberVar *ivar) {
+ AddrPatch *addrPatch;
+ ObjMemberVar *first, *current, *next;
+
+ if ((addrPatch = CPrec_FindAddrPatch(ivar)))
+ return addrPatch->value;
+
+ first = current = CPrec_AppendAlign();
+ CPrec_NewAddrPatch(ivar, first);
+
+ while (1) {
+ if (ivar->has_path) {
+ CPrec_AppendData(ivar, sizeof(ObjMemberVarPath));
+ if (OBJ_MEMBER_VAR_PATH(ivar)->path)
+ CPrec_NewPointerPatch(
+ &OBJ_MEMBER_VAR_PATH(current)->path,
+ CPrec_GetClassAccessPatch(OBJ_MEMBER_VAR_PATH(ivar)->path));
+ } else {
+ CPrec_AppendData(ivar, sizeof(ObjMemberVar));
+ }
+
+ if (ivar->name)
+ CPrec_NamePatch(¤t->name, ivar->name);
+ CPrec_NewPointerPatch(¤t->type, CPrec_GetTypePatch(ivar->type));
+
+ if (!ivar->next)
+ break;
+
+ if ((addrPatch = CPrec_FindAddrPatch(ivar->next))) {
+ CPrec_NewPointerPatch(¤t->next, addrPatch->value);
+ break;
+ }
+
+ next = CPrec_AppendAlign();
+ CPrec_NewPointerPatch(¤t->next, next);
+
+ current = next;
+ ivar = ivar->next;
+ CPrec_NewAddrPatch(ivar, current);
+ }
+ return first;
}
static DefArgCtorInfo *CPrec_GetDefArgCtorInfoPatch(DefArgCtorInfo *dac) {
@@ -1775,15 +2293,102 @@ static InlineXRef *CPrec_GetInlineXRefPatch(InlineXRef *ix) {
return first;
}
-static Object *CPrec_GetObjectPatch(Object *o) {
+static Object *CPrec_GetObjectPatch(Object *obj) {
+ AddrPatch *addrPatch;
+ Object *p;
+
+ if (CWUserBreak(cparams.context) != cwNoErr)
+ CError_UserBreak();
+
+ if ((addrPatch = CPrec_FindAddrPatch(obj)))
+ return addrPatch->value;
+
+ p = CPrec_AppendAlign();
+ CPrec_NewAddrPatch(obj, p);
+
+ obj->toc = NULL;
+
+ if ((obj->qual & Q_400000) && obj->datatype != DALIAS) {
+ CPrec_AppendData(obj, sizeof(ObjectTemplated));
+ CPrec_NewPointerPatch(&OBJECT_TEMPL(p)->parent, CPrec_GetObjectPatch(OBJECT_TEMPL(obj)->parent));
+ } else {
+ CPrec_AppendData(obj, sizeof(Object));
+ }
+
+ if (obj->nspace)
+ CPrec_NewPointerPatch(&p->nspace, CPrec_GetNameSpacePatch(obj->nspace));
+ if (obj->name)
+ CPrec_NamePatch(&p->name, obj->name);
+ CPrec_NewPointerPatch(&p->type, CPrec_GetTypePatch(obj->type));
+
+ switch (obj->datatype) {
+ case DABSOLUTE:
+ break;
+
+ case DLOCAL:
+ CError_FATAL(3580);
+ break;
+
+ case DFUNC:
+ case DVFUNC:
+ if (IS_TEMPL_FUNC(obj->type))
+ CPrec_NewPointerPatch(&p->u.func.u.templ, CPrec_GetTemplateFunctionPatch(obj->u.func.u.templ));
+ else if ((obj->qual & Q_INLINE) && obj->u.func.u.ifuncdata)
+ CPrec_NewPointerPatch(&p->u.func.u.ifuncdata, CPrec_GetInlineFuncPatch(obj->u.func.u.ifuncdata));
+
+ if (obj->u.func.defargdata)
+ CPrec_NewPointerPatch(&p->u.func.defargdata, CPrec_GetDefArgCtorInfoPatch(obj->u.func.defargdata));
+ if (obj->u.func.linkname)
+ CPrec_NamePatch(&p->u.func.linkname, obj->u.func.linkname);
+ if (obj->u.func.inst)
+ CPrec_NewPointerPatch(&p->u.func.inst, CPrec_GetTemplFuncInstancePatch(obj->u.func.inst));
+ break;
+
+ case DDATA:
+ CError_ASSERT(3622, !obj->u.data.info);
+ if (obj->qual & Q_10000) {
+ switch (obj->type->type) {
+ case TYPEINT:
+ case TYPEENUM:
+ case TYPEPOINTER:
+ break;
+ case TYPEFLOAT:
+ CPrec_RawMemPatch(&p->u.data.u.floatconst, obj->u.data.u.floatconst, sizeof(Float));
+ break;
+ default:
+ CError_FATAL(3638);
+ }
+ }
+ if (obj->u.data.linkname)
+ CPrec_NamePatch(&p->u.data.linkname, obj->u.data.linkname);
+ break;
+
+ case DINLINEFUNC:
+ CPrec_RawMemPatch(&p->u.ifunc.data, obj->u.ifunc.data, obj->u.ifunc.size);
+ if (obj->u.ifunc.xrefs)
+ CPrec_NewPointerPatch(&p->u.ifunc.xrefs, CPrec_GetInlineXRefPatch(obj->u.ifunc.xrefs));
+ break;
+
+ case DALIAS:
+ CPrec_NewPointerPatch(&p->u.alias.object, CPrec_GetObjectPatch(obj->u.alias.object));
+ if (obj->u.alias.member)
+ CPrec_NewPointerPatch(&p->u.alias.member, CPrec_GetClassAccessPatch(obj->u.alias.member));
+ break;
+
+ default:
+ CError_FATAL(3677);
+ }
+ if (cprec_dowrite)
+ obj->datatype = -1;
+
+ return p;
}
static ObjBase *CPrec_GetObjBasePatch(ObjBase *obj) {
switch (obj->otype) {
default:
-#line 3694
- CError_FATAL();
+ CError_FATAL(3694);
case OT_ENUMCONST:
return (ObjBase *) CPrec_GetObjEnumConstPatch((ObjEnumConst *) obj);
case OT_TYPE:
@@ -1945,29 +2550,230 @@ static NameSpace *CPrec_GetNameSpacePatch(NameSpace *nspace) {
return p;
}
-static void CPrec_DumpRootNameSpace() {}
-static void CPrec_GetSOMPatch() {}
-static void CPrec_GetOLinkPatch() {}
-static void CPrec_GetStaticDataPatch() {}
-static void CPrec_GetCallbackPatch() {}
-static void CPrec_GetSelHashTablePatch() {}
-static void CPrec_GetIExpressionPatch() {}
-static void CPrec_GetInlineActionPatch() {}
+static void CPrec_DumpRootNameSpace(void) {
+ NameSpaceList *nslist;
+ NameSpaceName *nsname;
+ int i;
-static void CPrec_GenerateBuiltinPatches() {
- int x;
- int y;
- Patch *scan;
+ CError_ASSERT(3905, cscope_root->is_hash);
- for (x = 0; x < cprec_builtins; x++) {
- y = 0;
- for (scan = cprec_builtin[x].patches; scan; scan = scan->next)
- ++y;
+ if (cscope_root->usings) {
+ nslist = CPrec_GetNameSpaceListPatch(cscope_root->usings);
+ if (cprec_dowrite)
+ cprec_header->usings = nslist;
+ }
- if (y) {
- CPrec_AppendWord32(y);
- CPrec_AppendWord32(x);
- for (scan = cprec_builtin[x].patches; scan; scan = scan->next)
+ if (cprec_dowrite)
+ cprec_header->root_names = cscope_root->names;
+
+ i = 0;
+ do {
+ if (cscope_root->data.hash[i]) {
+ nsname = CPrec_GetNameSpaceNamePatch(cscope_root->data.hash[i], 1);
+ if (cprec_dowrite) {
+ if (cprec_ioerror != noErr)
+ break;
+ cprec_header->root_nametable[i] = nsname;
+ }
+ }
+ } while (++i < 0x400);
+}
+
+static CSOMStub *CPrec_GetSOMPatch(CSOMStub *stub) {
+ CSOMStub *first, *current, *next;
+
+ first = current = CPrec_AppendAlign();
+ while (1) {
+ CPrec_AppendData(stub, sizeof(CSOMStub));
+
+ CPrec_NewPointerPatch(¤t->object, CPrec_GetObjectPatch(stub->object));
+ CPrec_NewPointerPatch(¤t->tclass, CPrec_GetTypePatch(TYPE(stub->tclass)));
+
+ if (!stub->next)
+ break;
+
+ next = CPrec_AppendAlign();
+ CPrec_NewPointerPatch(¤t->next, next);
+ current = next;
+ stub = stub->next;
+ }
+
+ return first;
+}
+
+static OLinkList *CPrec_GetOLinkPatch(OLinkList *olink) {
+ OLinkList *first, *current, *next;
+
+ first = current = CPrec_AppendAlign();
+ while (1) {
+ CPrec_AppendData(olink, sizeof(OLinkList));
+
+ CPrec_NewPointerPatch(¤t->obj, CPrec_GetObjectPatch(olink->obj));
+
+ if (!olink->next)
+ break;
+
+ next = CPrec_AppendAlign();
+ CPrec_NewPointerPatch(¤t->next, next);
+ current = next;
+ olink = olink->next;
+ }
+
+ return first;
+}
+
+static StaticData *CPrec_GetStaticDataPatch(StaticData *sd) {
+ StaticData *current, *first, *next;
+
+ first = current = CPrec_AppendAlign();
+ while (1) {
+ CPrec_AppendData(sd, sizeof(StaticData));
+
+ CPrec_NewPointerPatch(¤t->object, CPrec_GetObjectPatch(sd->object));
+ if (sd->buffer)
+ CPrec_RawMemPatch(¤t->buffer, sd->buffer, sd->object->type->size);
+ if (sd->links)
+ CPrec_NewPointerPatch(¤t->links, CPrec_GetOLinkPatch(sd->links));
+
+ if (!sd->next)
+ break;
+
+ next = CPrec_AppendAlign();
+ CPrec_NewPointerPatch(¤t->next, next);
+ current = next;
+ sd = sd->next;
+ }
+
+ return first;
+}
+
+static CallbackAction *CPrec_GetCallbackPatch(CallbackAction *ca) {
+ CallbackAction *first, *current, *next;
+
+ first = current = CPrec_AppendAlign();
+ while (1) {
+ CPrec_AppendData(ca, sizeof(CallbackAction));
+
+ CPrec_NewPointerPatch(¤t->obj, CPrec_GetObjectPatch(ca->obj));
+ CPrec_NewPointerPatch(¤t->tclass, CPrec_GetTypePatch(TYPE(ca->tclass)));
+
+ if (!ca->next)
+ break;
+
+ next = CPrec_AppendAlign();
+ CPrec_NewPointerPatch(¤t->next, next);
+ current = next;
+ ca = ca->next;
+ }
+
+ return first;
+}
+
+static ObjCSelector **CPrec_GetSelHashTablePatch(ObjCSelector **table) {
+ ObjCSelector **first, **current;
+ int i;
+
+ first = current = CPrec_AppendAlign();
+ CPrec_AppendData(table, sizeof(ObjCSelector *) * 0x400);
+
+ for (i = 0; i < 0x400; i++) {
+ if (*table)
+ CPrec_NewPointerPatch(current, CPrec_GetObjCSelectorPatch(*table));
+ table++;
+ current++;
+ }
+
+ return first;
+}
+
+static InitExpr *CPrec_GetIExpressionPatch(InitExpr *initexpr) {
+ InitExpr *first, *current, *next;
+
+ first = current = CPrec_AppendAlign();
+ while (1) {
+ CPrec_AppendData(initexpr, sizeof(InitExpr));
+
+ CPrec_NewPointerPatch(¤t->object, CPrec_GetObjectPatch(initexpr->object));
+ CPrec_NewPointerPatch(¤t->expr, CPrec_GetExpressionPatch(initexpr->expr));
+
+ if (!initexpr->next)
+ break;
+
+ next = CPrec_AppendAlign();
+ CPrec_NewPointerPatch(¤t->next, next);
+ current = next;
+ initexpr = initexpr->next;
+ }
+
+ return first;
+}
+
+static CI_Action *CPrec_GetInlineActionPatch(CI_Action *act) {
+ CI_Action *current, *first, *next;
+
+ first = current = CPrec_AppendAlign();
+ while (1) {
+ if (act->actiontype == CI_ActionInlineFunc)
+ memclrw(&act->u.inlinefunc.fileoffset, sizeof(FileOffsetInfo));
+
+ CPrec_AppendData(act, sizeof(CI_Action));
+
+ CPrec_NewPointerPatch(¤t->obj, CPrec_GetObjectPatch(act->obj));
+
+ switch (act->actiontype) {
+ case CI_ActionInlineFunc:
+ if (act->u.inlinefunc.stream.firsttoken)
+ CPrec_NewPointerPatch(
+ ¤t->u.inlinefunc.stream.firsttoken,
+ CPrec_GetTStreamPatch(act->u.inlinefunc.stream.firsttoken, act->u.inlinefunc.stream.tokens));
+ if (act->u.inlinefunc.tclass)
+ CPrec_NewPointerPatch(¤t->u.inlinefunc.tclass, CPrec_GetTypePatch(TYPE(act->u.inlinefunc.tclass)));
+ break;
+
+ case CI_ActionMemberFunc:
+ CPrec_NewPointerPatch(¤t->u.memberfunc.templ, CPrec_GetTypePatch(TYPE(act->u.memberfunc.templ)));
+ CPrec_NewPointerPatch(¤t->u.memberfunc.inst, CPrec_GetTypePatch(TYPE(act->u.memberfunc.inst)));
+ CPrec_NewPointerPatch(¤t->u.memberfunc.tmemb, CPrec_GetTemplateMemberPatch(act->u.memberfunc.tmemb));
+ break;
+
+ case CI_ActionTemplateFunc:
+ CPrec_NewPointerPatch(¤t->u.templatefunc.func, CPrec_GetTemplateFunctionPatch(act->u.templatefunc.func));
+ CPrec_NewPointerPatch(¤t->u.templatefunc.inst, CPrec_GetTemplFuncInstancePatch(act->u.templatefunc.inst));
+ break;
+
+ case CI_ActionDefaultFunc:
+ break;
+
+ default:
+ CError_FATAL(4177);
+ }
+
+ if (!act->next)
+ break;
+
+ next = CPrec_AppendAlign();
+ CPrec_NewPointerPatch(¤t->next, next);
+ current = next;
+ act = act->next;
+ }
+
+ return first;
+}
+
+static void CPrec_GenerateBuiltinPatches(void) {
+ int x;
+ int y;
+ Patch *scan;
+
+ for (x = 0; x < cprec_builtins; x++) {
+ y = 0;
+ for (scan = cprec_builtin[x].patches; scan; scan = scan->next)
+ ++y;
+
+ if (y) {
+ CPrec_AppendWord32(y);
+ CPrec_AppendWord32(x);
+ for (scan = cprec_builtin[x].patches; scan; scan = scan->next)
CPrec_AppendWord32(scan->offset);
}
}
@@ -1975,7 +2781,7 @@ static void CPrec_GenerateBuiltinPatches() {
CPrec_AppendWord32(0);
}
-static void CPrec_GenerateTokenStreamPatches() {
+static void CPrec_GenerateTokenStreamPatches(void) {
TokenPatch *scan;
for (scan = cprec_tokenpatches; scan; scan = scan->next) {
@@ -2032,7 +2838,7 @@ static OSErr CPrec_CompressWrite(const char *data, SInt32 size) {
return noErr;
}
-static OSErr CPrec_FlushRawBuffer() {
+static OSErr CPrec_FlushRawBuffer(void) {
OSErr err;
if (cprec_dowrite) {
@@ -2049,7 +2855,7 @@ static OSErr CPrec_FlushRawBuffer() {
}
}
-static OSErr CPrec_FlushBufferCheck() {
+static OSErr CPrec_FlushBufferCheck(void) {
static SInt32 flushmax;
OSErr err;
@@ -2067,7 +2873,7 @@ static OSErr CPrec_FlushBufferCheck() {
return noErr;
}
-static int CPrec_CompressPatches() {
+static int CPrec_CompressPatches(void) {
Patch *scan;
int count;
SInt32 last;
@@ -2078,8 +2884,7 @@ static int CPrec_CompressPatches() {
last = 0;
count = 0;
while (scan) {
-#line 4339
- CError_ASSERT((scan->offset & 0x80000001) == 0);
+ CError_ASSERT(4339, (scan->offset & 0x80000001) == 0);
if ((scan->offset - last) >= -128 && (scan->offset - last) <= 126)
CPrec_AppendByte(((scan->offset - last) >> 1) | 0x80);
@@ -2094,7 +2899,146 @@ static int CPrec_CompressPatches() {
return count;
}
-static void CPrec_DumpColorSymbolTable() {}
+static OSErr CPrec_DumpColorSymbolTable(Boolean doWrite) {
+ OSErr err;
+
+ freelheap();
+
+ CPrec_InitAddressHashTable();
+ CPrec_InitPointerHashTable();
+
+ cprec_patch_list = NULL;
+ cprec_tokenpatches = NULL;
+ cprec_offset = 0;
+ cprec_zero_offset = 0;
+ cprec_dowrite = doWrite;
+ cprec_ioerror = noErr;
+
+ CPrec_SetupBuiltIn();
+ CPrec_AppendWord32(0);
+
+ CPrec_DumpNameTable();
+ if ((err = CPrec_FlushRawBuffer()) != noErr)
+ return err;
+
+ CPrec_DumpMacroTable();
+ if ((err = CPrec_FlushRawBuffer()) != noErr)
+ return err;
+
+ CPrec_DumpRootNameSpace();
+ if (doWrite) {
+ if (cprec_ioerror != noErr)
+ return cprec_ioerror;
+ if ((err = CPrec_FlushRawBuffer()) != noErr)
+ return err;
+ }
+
+ if (ctempl_templates) {
+ TemplClass *p = TEMPL_CLASS(CPrec_GetTypePatch(TYPE(ctempl_templates)));
+ if (doWrite)
+ cprec_header->ctempl_templates = p;
+ if ((err = CPrec_FlushRawBuffer()) != noErr)
+ return err;
+ }
+
+ if (ctempl_templatefuncs) {
+ TemplateFunction *p = CPrec_GetTemplateFunctionPatch(ctempl_templatefuncs);
+ if (doWrite)
+ cprec_header->ctempl_templatefuncs = p;
+ if ((err = CPrec_FlushRawBuffer()) != noErr)
+ return err;
+ }
+
+ if (csom_stubs) {
+ CSOMStub *p = CPrec_GetSOMPatch(csom_stubs);
+ if (doWrite)
+ cprec_header->csom_stubs = p;
+ if ((err = CPrec_FlushRawBuffer()) != noErr)
+ return err;
+ }
+
+ if (cprec_staticdata) {
+ StaticData *p = CPrec_GetStaticDataPatch(cprec_staticdata);
+ if (doWrite)
+ cprec_header->cprec_staticdata = p;
+ if ((err = CPrec_FlushRawBuffer()) != noErr)
+ return err;
+ }
+
+ if (callbackactions) {
+ CallbackAction *p = CPrec_GetCallbackPatch(callbackactions);
+ if (doWrite)
+ cprec_header->callbackactions = p;
+ if ((err = CPrec_FlushRawBuffer()) != noErr)
+ return err;
+ }
+
+ if (cobjc_type_class) {
+ Type *p = CPrec_GetTypePatch(cobjc_type_class);
+ if (doWrite)
+ cprec_header->cobjc_type_class = p;
+ if ((err = CPrec_FlushRawBuffer()) != noErr)
+ return err;
+ }
+
+ if (cobjc_type_id) {
+ Type *p = CPrec_GetTypePatch(cobjc_type_id);
+ if (doWrite)
+ cprec_header->cobjc_type_id = p;
+ if ((err = CPrec_FlushRawBuffer()) != noErr)
+ return err;
+ }
+
+ if (cobjc_type_sel) {
+ Type *p = CPrec_GetTypePatch(cobjc_type_sel);
+ if (doWrite)
+ cprec_header->cobjc_type_sel = p;
+ if ((err = CPrec_FlushRawBuffer()) != noErr)
+ return err;
+ }
+
+ if (cobjc_selhashtable) {
+ ObjCSelector **p = CPrec_GetSelHashTablePatch(cobjc_selhashtable);
+ if (doWrite)
+ cprec_header->cobjc_selhashtable = p;
+ if ((err = CPrec_FlushRawBuffer()) != noErr)
+ return err;
+ }
+
+ if (cobjc_classdefs) {
+ BClassList *p = CPrec_GetBClassListPatch(cobjc_classdefs);
+ if (doWrite)
+ cprec_header->cobjc_classdefs = p;
+ if ((err = CPrec_FlushRawBuffer()) != noErr)
+ return err;
+ }
+
+ if (cobjc_protocols) {
+ ObjCProtocol *p = CPrec_GetObjCProtocolPatch(cobjc_protocols);
+ if (doWrite)
+ cprec_header->cobjc_protocols = p;
+ if ((err = CPrec_FlushRawBuffer()) != noErr)
+ return err;
+ }
+
+ if (init_expressions) {
+ InitExpr *p = CPrec_GetIExpressionPatch(init_expressions);
+ if (doWrite)
+ cprec_header->init_expressions = p;
+ if ((err = CPrec_FlushRawBuffer()) != noErr)
+ return err;
+ }
+
+ if (cinline_tactionlist) {
+ CI_Action *p = CPrec_GetInlineActionPatch(cinline_tactionlist);
+ if (doWrite)
+ cprec_header->cinline_tactionlist = p;
+ if ((err = CPrec_FlushRawBuffer()) != noErr)
+ return err;
+ }
+
+ return noErr;
+}
static OSErr CPrec_FileAlign(short refnum, SInt32 *len) {
OSErr err;
@@ -2112,21 +3056,341 @@ static OSErr CPrec_FileAlign(short refnum, SInt32 *len) {
return err;
}
-static void CPrec_WriteFile() {}
+static OSErr CPrec_WriteFile(void) {
+ char str[128];
+ int i;
+ HashNameNode *name;
+ OSErr err;
+ SInt32 offset;
+
+ if (InitGList(&cprec_glist, 0x40000))
+ CError_NoMem();
+
+ CompilerGetCString(10, str);
+ CWShowStatus(cparams.context, str, "");
+ CPrep_RemoveSpecialMacros();
+
+ for (i = 0; i < 0x800; i++) {
+ for (name = name_hash_nodes[i]; name; name = name->next)
+ name->id = 0;
+ }
+
+ if ((err = CPrec_DumpColorSymbolTable(0)) != noErr)
+ return err;
+
+ CompilerGetCString(11, str);
+ CWShowStatus(cparams.context, str, "");
+
+ cprec_header = galloc(sizeof(Header));
+ memclrw(cprec_header, sizeof(Header));
+
+ cprec_header->magic = 0xBEEFFACE;
+ cprec_header->version = 1047;
+ cprec_header->target = 2;
+ cprec_header->check_header_flags = copts.check_header_flags;
+ cprec_header->cplusplus = copts.cplusplus;
+ cprec_header->uniqueID = CParser_GetUniqueID();
+ cprec_header->cobjc_selrefcount = cobjc_selrefcount;
+ cprec_header->cobjc_classrefcount = cobjc_classrefcount;
+ cprec_header->cobjc_stringcount = cobjc_stringcount;
+
+ if ((err = COS_FileWrite(cprec_refnum, cprec_header, sizeof(Header))) != noErr)
+ return err;
+
+ offset = sizeof(Header);
+
+ if ((err = CPrec_DumpColorSymbolTable(1)) != noErr)
+ return err;
+
+ cprec_header->x28 = cprec_offset;
+ cprec_header->x30 = offset;
+
+ if ((err = COS_FileGetPos(cprec_refnum, &offset)) != noErr)
+ return err;
+
+ cprec_header->x2C = offset - cprec_header->x30;
+
+ cprec_header->compressedPatchCount = CPrec_CompressPatches();
+ cprec_header->compressedPatchSize = cprec_glist.size;
+ cprec_header->compressedPatchOffset = offset;
+
+ if (cprec_header->compressedPatchCount) {
+ if ((err = COS_FileWrite(cprec_refnum, *cprec_glist.data, cprec_glist.size)) != noErr)
+ return err;
+ offset += cprec_glist.size;
+ }
+
+ if ((err = CPrec_FileAlign(cprec_refnum, &offset)) != noErr)
+ return err;
+
+ cprec_glist.size = 0;
+ CPrec_GenerateBuiltinPatches();
+ cprec_header->builtinPatchSize = cprec_glist.size;
+ cprec_header->builtinPatchOffset = offset;
+
+ if ((err = COS_FileWrite(cprec_refnum, *cprec_glist.data, cprec_glist.size)) != noErr)
+ return err;
+ offset += cprec_glist.size;
+
+ if (cprec_tokenpatches) {
+ cprec_glist.size = 0;
+ CPrec_GenerateTokenStreamPatches();
+ cprec_header->tokenStreamPatchSize = cprec_glist.size;
+ cprec_header->tokenStreamPatchOffset = offset;
+
+ if ((err = COS_FileWrite(cprec_refnum, *cprec_glist.data, cprec_glist.size)) != noErr)
+ return err;
+ offset += cprec_glist.size;
+ }
+
+ if ((err = COS_FileSetPos(cprec_refnum, 0)) != noErr)
+ return err;
+
+ if ((err = COS_FileWrite(cprec_refnum, cprec_header, sizeof(Header))) != noErr)
+ return err;
+
+ return noErr;
+}
+
+void PrecompilerWrite(void) {
+ OSErr err;
+ short strindex;
+ char str[128];
+ FSSpec spec;
+
+ spec = cparamblkptr->mainFileSpec;
+ if (CWGetPrecompiledHeaderSpec(cparamblkptr->context, &spec, precomp_target_str) == cwNoErr) {
+ strindex = 3;
+ err = COS_FileNew(&spec, &cprec_refnum, copts.pchCreator, copts.pchType);
+ if (err == noErr) {
+ strindex = 4;
+ err = CPrec_WriteFile();
+ }
+ CleanupPrecompiler();
+
+ if (err != noErr) {
+ CompilerGetCString(strindex, str);
+ sprintf(string, str, err);
+ CWReportMessage(cparamblkptr->context, NULL, string, NULL, messagetypeError, 0);
+ } else {
+ CWFileTime time = 0;
+ CWSetModDate(cparamblkptr->context, &spec, &time, 1);
+ }
+ }
+}
-void PrecompilerWrite() {
+static void CPrec_ReadData(SInt32 offset, void *buffer, SInt32 size) {
+ if (
+ COS_FileSetPos(cprec_refnum, offset) != noErr ||
+ COS_FileRead(cprec_refnum, buffer, size) != noErr
+ )
+ CError_ErrorTerm(CErrorStr181);
}
-static void CPrec_ReadData() {}
-static void CPrec_ReadRawBuffer() {}
-static void CPrec_RelocateRawBuffer() {}
-static void CPrec_RelocateBuiltins() {}
-static void CPrec_RelocateTokenStreams() {}
-static void CPrec_RelocateMacroTable() {}
-static void CPrec_RelocateTable() {}
-static void CPrec_RelocateRootNameSpace() {}
+static void CPrec_ReadRawBuffer(void) {
+ UInt8 *buffer;
+ UInt8 *work;
+ UInt8 *end;
+ UInt32 size;
+ int ch;
+
+ if (!cprec_buffer) {
+ size = cprec_header->x28 + (cprec_header->x28 >> 7) + 64;
+ buffer = galloc(size);
+ cprec_rawbuffer = buffer;
+
+ work = buffer + size - cprec_header->x2C;
+ CPrec_ReadData(cprec_header->x30, work, cprec_header->x2C);
+ } else {
+ buffer = galloc(cprec_header->x28);
+ cprec_rawbuffer = buffer;
+ work = (UInt8 *) cprec_buffer + cprec_header->x30;
+ }
+
+ end = work + cprec_header->x2C;
-static void CPrec_FixNameIds() {
+ while (work < end) {
+ if ((ch = *(work++)) >= 0xE0) {
+ ch -= 0xE0;
+ do {
+ *(buffer++) = 0;
+ } while (--ch >= 0);
+ } else {
+ do {
+ *(buffer++) = *(work++);
+ } while (--ch >= 0);
+ }
+ }
+
+ if (work != end || buffer != RESOLVE_RAW_BUFFER(cprec_header->x28))
+ CError_ErrorTerm(CErrorStr181);
+}
+
+static void CPrec_RelocateRawBuffer(void) {
+ UInt8 *patches;
+ UInt32 offset;
+ UInt8 *dest;
+ SInt32 count;
+ UInt8 *patch;
+ UInt32 var;
+
+ if ((count = cprec_header->compressedPatchCount)) {
+ if (!cprec_buffer) {
+ patches = lalloc(cprec_header->compressedPatchSize);
+ CPrec_ReadData(cprec_header->compressedPatchOffset, patches, cprec_header->compressedPatchSize);
+ } else {
+ patches = RESOLVE_BUFFER(cprec_header->compressedPatchOffset);
+ }
+
+ offset = 0;
+ patch = patches;
+ dest = cprec_rawbuffer;
+ do {
+ if (!(*patch & 0x80)) {
+ ((UInt8 *) &var)[0] = *(patch++);
+ ((UInt8 *) &var)[1] = *(patch++);
+ ((UInt8 *) &var)[2] = *(patch++);
+ ((UInt8 *) &var)[3] = *(patch++);
+ offset = var;
+ } else {
+ offset += (char) (*(patch++) * 2);
+ }
+ *((uintptr_t *) (dest + offset)) += (uintptr_t) dest;
+ } while (--count > 0);
+
+ freelheap();
+
+ if (patch != (patches + cprec_header->compressedPatchSize))
+ CError_ErrorTerm(CErrorStr181);
+ }
+}
+
+static void CPrec_RelocateBuiltins(void) {
+ UInt32 *patches;
+ void *builtin;
+ UInt32 count;
+ UInt8 *buffer;
+
+ if (cprec_header->builtinPatchSize) {
+ CPrec_SetupBuiltInArray();
+ if (!cprec_buffer) {
+ patches = lalloc(cprec_header->builtinPatchSize);
+ CPrec_ReadData(cprec_header->builtinPatchOffset, patches, cprec_header->builtinPatchSize);
+ } else {
+ patches = RESOLVE_BUFFER(cprec_header->builtinPatchOffset);
+ }
+
+ buffer = cprec_rawbuffer;
+ while (1) {
+ if (!(count = *(patches++)))
+ break;
+
+ builtin = cprec_builtin_array[*(patches++)];
+ do {
+ *((void **) (buffer + *(patches++))) = builtin;
+ } while (--count);
+ }
+ }
+}
+
+static void CPrec_RelocateTokenStreams(void) {
+ UInt32 *patches;
+ UInt32 count;
+ TStreamElement *tokens;
+ UInt8 *buffer;
+ CPrepFileInfo *file;
+ SInt32 pos;
+
+ if (cprec_header->tokenStreamPatchSize) {
+ CPrep_GetPrepPos(&file, &pos);
+
+ if (!cprec_buffer) {
+ patches = lalloc(cprec_header->tokenStreamPatchSize);
+ CPrec_ReadData(cprec_header->tokenStreamPatchOffset, patches, cprec_header->tokenStreamPatchSize);
+ } else {
+ patches = RESOLVE_BUFFER(cprec_header->tokenStreamPatchOffset);
+ }
+
+ buffer = cprec_rawbuffer;
+ while (1) {
+ if (!*patches)
+ break;
+
+ tokens = (TStreamElement *) (buffer + *(patches++));
+ count = *(patches++);
+
+ while (count--) {
+ tokens->tokenfile = file;
+ tokens->tokenoffset = pos;
+ tokens++;
+ }
+ }
+ }
+}
+
+static void CPrec_RelocateMacroTable(void) {
+ int i;
+ int j;
+ int count;
+ UInt8 *buffer;
+ Macro **prec_table;
+ Macro **table;
+ Macro *macro;
+ uintptr_t offset;
+
+ buffer = cprec_rawbuffer;
+ prec_table = cprec_header->macrotable;
+ table = macrohashtable;
+
+ i = 0;
+ do {
+ for (macro = *table; macro; macro = macro->next) {
+ macro->name = GetHashNameNodeExport(macro->name->name);
+ count = macro->xC & 0x7FFF;
+ for (j = 1; j < count; j++)
+ macro->names[j - 1] = GetHashNameNodeExport(macro->names[j - 1]->name);
+ }
+
+ if ((offset = (uintptr_t) *prec_table)) {
+ if (*table) {
+ macro = (Macro *) (buffer + offset);
+ while (macro->next)
+ macro = macro->next;
+ macro->next = *table;
+ }
+ *table = (Macro *) (buffer + offset);
+ }
+
+ prec_table++;
+ table++;
+ } while (++i < 0x800);
+}
+
+static void CPrec_RelocateTable(void **table, int size, void **dest) {
+ int i;
+ void *buffer = cprec_rawbuffer;
+
+ for (i = 0; i < size; i++) {
+ if (*table)
+ *dest = (char *) buffer + (uintptr_t) *table;
+ else
+ *dest = NULL;
+ table++;
+ dest++;
+ }
+}
+
+static void CPrec_RelocateRootNameSpace(void) {
+ CError_ASSERT(4981, cscope_root->is_hash);
+
+ cscope_root->names = cprec_header->root_names;
+ CPrec_RelocateTable(
+ (void **) cprec_header->root_nametable,
+ 0x400,
+ (void **) cscope_root->data.hash);
+}
+
+static void CPrec_FixNameIds(void) {
int i;
HashNameNode *node;
@@ -2136,7 +3400,83 @@ static void CPrec_FixNameIds() {
}
}
-static void CPrec_DefineStaticData() {}
+static void CPrec_DefineStaticData(void) {
+ StaticData *sd = cprec_staticdata;
+ cprec_staticdata = NULL;
+
+ while (sd) {
+ CInit_DeclareData(sd->object, sd->buffer, sd->links, sd->size);
+ sd = sd->next;
+ }
+}
void PrecompilerRead(short refnum, void *buffer) {
+ cprec_refnum = refnum;
+ cprec_buffer = buffer;
+
+ CPrep_RemoveSpecialMacros();
+
+ if (!CScope_IsEmptySymTable())
+ CError_ErrorTerm(CErrorStr180);
+
+ if (!cprec_buffer) {
+ cprec_header = galloc(sizeof(Header));
+ CPrec_ReadData(0, cprec_header, sizeof(Header));
+ } else {
+ cprec_header = cprec_buffer;
+ }
+
+ if (cprec_header->magic != 0xBEEFFACE)
+ CError_ErrorTerm(CErrorStr181);
+ if (cprec_header->version != 1047)
+ CError_ErrorTerm(CErrorStr222);
+ if (cprec_header->target != 2)
+ CError_ErrorTerm(CErrorStr223);
+
+ copts.check_header_flags = cprec_header->check_header_flags;
+
+ CPrec_ReadRawBuffer();
+ CPrec_RelocateRawBuffer();
+ CPrec_RelocateBuiltins();
+ CPrec_RelocateTable((void **) cprec_header->nametable, 0x800, (void **) name_hash_nodes);
+ CPrec_FixNameIds();
+ CPrec_RelocateMacroTable();
+ CPrec_RelocateTokenStreams();
+ CPrec_RelocateRootNameSpace();
+
+ if (!cprec_header->usings)
+ cscope_root->usings = NULL;
+ else
+ cscope_root->usings = RESOLVE_RAW_BUFFER(cprec_header->usings);
+
+ ctempl_templates = RESOLVE_SAFE(cprec_header->ctempl_templates);
+ ctempl_templatefuncs = RESOLVE_SAFE(cprec_header->ctempl_templatefuncs);
+ csom_stubs = RESOLVE_SAFE(cprec_header->csom_stubs);
+ cprec_staticdata = RESOLVE_SAFE(cprec_header->cprec_staticdata);
+ callbackactions = RESOLVE_SAFE(cprec_header->callbackactions);
+ cobjc_type_class = RESOLVE_SAFE(cprec_header->cobjc_type_class);
+ cobjc_type_id = RESOLVE_SAFE(cprec_header->cobjc_type_id);
+ cobjc_type_sel = RESOLVE_SAFE(cprec_header->cobjc_type_sel);
+ cobjc_selhashtable = RESOLVE_SAFE(cprec_header->cobjc_selhashtable);
+ cobjc_classdefs = RESOLVE_SAFE(cprec_header->cobjc_classdefs);
+ cobjc_protocols = RESOLVE_SAFE(cprec_header->cobjc_protocols);
+ init_expressions = RESOLVE_SAFE(cprec_header->init_expressions);
+ cinline_tactionlist = RESOLVE_SAFE(cprec_header->cinline_tactionlist);
+ CParser_SetUniqueID(cprec_header->uniqueID);
+ cobjc_selrefcount = cprec_header->cobjc_selrefcount;
+ cobjc_classrefcount = cprec_header->cobjc_classrefcount;
+ cobjc_stringcount = cprec_header->cobjc_stringcount;
+
+ cprec_refnum = 0;
+
+ CleanupPrecompiler();
+ cscope_current = cscope_root;
+
+ if (!CParser_ReInitRuntimeObjects(1))
+ CError_ErrorTerm(CErrorStr181);
+
+ CPrep_InsertSpecialMacros();
+
+ if (cparamblkptr->isPrecompiling != 1)
+ CPrec_DefineStaticData();
}
diff --git a/compiler_and_linker/unsorted/CodeGen.c b/compiler_and_linker/unsorted/CodeGen.c
index 7b73bee..8268736 100644
--- a/compiler_and_linker/unsorted/CodeGen.c
+++ b/compiler_and_linker/unsorted/CodeGen.c
@@ -7,57 +7,40 @@
#include "compiler/CInt64.h"
#include "compiler/CMachine.h"
#include "compiler/CMangler.h"
+#include "compiler/COptimizer.h"
#include "compiler/CParser.h"
#include "compiler/CPrep.h"
#include "compiler/CPrepTokenizer.h"
+#include "compiler/Coloring.h"
+#include "compiler/CompilerTools.h"
+#include "compiler/uDump.h"
+#include "compiler/Exceptions.h"
+#include "compiler/InlineAsmPPC.h"
+#include "compiler/Intrinsics.h"
#include "compiler/InstrSelection.h"
+#include "compiler/GlobalOptimizer.h"
+#include "compiler/ObjGenMachO.h"
#include "compiler/Operands.h"
#include "compiler/PCode.h"
+#include "compiler/PCodeAssembly.h"
#include "compiler/PCodeInfo.h"
+#include "compiler/PCodeListing.h"
#include "compiler/PCodeUtilities.h"
+#include "compiler/Peephole.h"
+#include "compiler/PPCError.h"
#include "compiler/RegisterInfo.h"
+#include "compiler/Scheduler.h"
#include "compiler/StackFrame.h"
+#include "compiler/Switch.h"
#include "compiler/TOC.h"
-#include "compiler/CompilerTools.h"
+#include "compiler/ValueNumbering.h"
#include "compiler/enode.h"
+#include "compiler/objc.h"
#include "compiler/objects.h"
#include "compiler/scopes.h"
#include "compiler/tokens.h"
#include "compiler/types.h"
-// TODO: MOVE ME
-extern void Intrinsics_SetupRuntimeObjects(void);
-extern void Intrinsics_ReInitRuntimeObjects(Boolean);
-extern Boolean Intrinsics_IsPublicRuntimeObject(Object *);
-extern ENode *Intrinsics_HandleIntrinsicCall(Object *func, ENodeList *arg_exprs);
-extern void PPCError_Error(int, ...);
-extern void PPCError_Warning(int, ...);
-extern void PPCError_Message(char *, ...);
-extern void globallyoptimizepcode(Object *);
-extern void pclistblocks(char *, char *);
-extern void pclistblocks_start_scheduler(char *, char *);
-extern void pclistblocks_end_scheduler();
-extern void scheduleinstructions(Boolean);
-extern void peepholemergeblocks(Object *, Boolean);
-extern void peepholeoptimizeforward(Object *);
-extern void peepholeoptimizepcode(Object *);
-extern void colorinstructions(Object *);
-extern void removecommonsubexpressions(Object *, Boolean);
-extern int removedcommonsubexpressions;
-extern SInt32 assemblefunction(Object *, void *);
-extern void dumpswitchtables(Object *);
-extern void ObjGen_DeclareInitFunction(Object *);
-extern void *switchtables;
-extern void initializeexceptiontables();
-extern void dumpexceptiontables(Object *, SInt32);
-extern void switchstatement(ENode *, CLabel *);
-extern void DumpIR(Statement **, Object *);
-extern void InlineAsm_TranslateIRtoPCode(Statement *stmt);
-typedef struct WeirdInlineAsmThing {
- UInt8 x0, x1, x2;
-} WeirdInlineAsmThing;
-extern Statement **COpt_Optimizer(Object *, Statement **);
-
static Macro powcM;
static Macro __powcM;
static Macro ppc_cpu;
@@ -876,7 +859,7 @@ static void callprofiler(char *name) {
static void exitprofiler(void) {
}
-void CodeGen_Generator(Statement **statements, Object *func, UInt8 mysteryFlag, Boolean callOnModuleBind) {
+void CodeGen_Generator(Statement *statements, Object *func, UInt8 mysteryFlag, Boolean callOnModuleBind) {
Statement *stmt;
Boolean has_varargs;
PCodeBlock *tmp;
@@ -924,7 +907,7 @@ void CodeGen_Generator(Statement **statements, Object *func, UInt8 mysteryFlag,
resetTOCvarinfo();
init_registers();
- expandTOCreferences(statements);
+ expandTOCreferences(&statements->next);
if (copts.debuglisting)
DumpIR(statements, func);
@@ -953,10 +936,10 @@ void CodeGen_Generator(Statement **statements, Object *func, UInt8 mysteryFlag,
if (copts.profile)
callprofiler(CMangler_GetLinkName(func)->name);
- assign_labels(*statements);
+ assign_labels(statements->next);
open_temp_registers();
- for (stmt = *statements; stmt; stmt = stmt->next) {
+ for (stmt = statements->next; stmt; stmt = stmt->next) {
current_statement = stmt;
current_linenumber = stmt->sourceoffset;
switch (stmt->type) {
@@ -991,7 +974,7 @@ void CodeGen_Generator(Statement **statements, Object *func, UInt8 mysteryFlag,
break;
case ST_SWITCH:
newstatement(stmt->sourceoffset, stmt->value, (stmt->flags & StmtFlag_10) != 0);
- switchstatement(stmt->expr, stmt->label);
+ switchstatement(stmt->expr, (SwitchInfo *) stmt->label);
break;
case ST_BEGINCATCH:
capturestackpointer(stmt->expr->data.objref);
@@ -1010,8 +993,7 @@ void CodeGen_Generator(Statement **statements, Object *func, UInt8 mysteryFlag,
break;
case ST_ASM:
if (stmt->expr) {
- // ... will need to understand inline ASM properly for this ...
- if (((WeirdInlineAsmThing *) stmt->expr)->x2 & 1) {
+ if (((InlineAsm *) stmt->expr)->flags & IAFlag1) {
CError_FATAL(2076);
} else {
branch_label(makepclabel());
@@ -1911,19 +1893,69 @@ void CodeGen_UpdateBackEndOptions(void) {
}
SInt32 CodeGen_objc_method_self_offset(ObjCMethod *meth) {
- // TODO objc
+ SInt32 size;
+
+ if (!meth->return_type) {
+ size = 4;
+ } else if (
+ IS_TYPE_ARRAY(meth->return_type) ||
+ IS_TYPE_NONVECTOR_STRUCT(meth->return_type) ||
+ IS_TYPE_CLASS(meth->return_type) ||
+ IS_TYPE_12BYTES_MEMBERPOINTER(meth->return_type)
+ )
+ {
+ size = 8;
+ } else {
+ size = meth->return_type->size;
+ }
+
+ if (size == 0)
+ size = 1;
+
+ return (size + 3) & ~3;
}
SInt32 CodeGen_objc_method_sel_offset(ObjCMethod *meth) {
- // TODO objc
+ return (CodeGen_objc_method_self_offset(meth) + 7) & ~3;
}
SInt32 CodeGen_objc_method_arg_offset(ObjCMethod *meth, ObjCMethodArg *arg) {
- // TODO objc
+ SInt32 pos;
+ ObjCMethodArg *scan;
+
+ pos = CodeGen_objc_method_sel_offset(meth) + 4;
+ for (scan = meth->selector_args; scan; scan = scan->next) {
+ if (scan == arg)
+ return pos;
+
+ if (scan->type == NULL)
+ pos += 4;
+ else
+ pos += scan->type->size;
+
+ pos = (pos + 3) & ~3;
+ }
+
+ return 0;
}
SInt32 CodeGen_objc_method_args_size(ObjCMethod *meth) {
- // TODO objc
+ SInt32 size;
+ ObjCMethodArg *scan;
+
+ size = CodeGen_objc_method_self_offset(meth);
+ for (scan = meth->selector_args; scan; scan = scan->next) {
+ if (scan->next == NULL && scan->type == NULL)
+ return size;
+
+ size = (size + 3) & ~3;
+ if (scan->type == NULL)
+ size += 4;
+ else
+ size += scan->type->size;
+ }
+
+ return size;
}
ENode *CodeGen_HandleIntrinsicCall(Object *func, ENodeList *arg_exprs) {
@@ -1959,11 +1991,16 @@ ENode *CodeGen_HandleTypeCast(ENode *expr, Type *type, UInt32 qual) {
return NULL;
}
-short CodeGen_AssignCheck(ENode *expr, Type *type, Boolean flag1, Boolean flag2) {
+short CodeGen_AssignCheck(const ENode *expr, const Type *type, Boolean flag1, Boolean flag2) {
short result;
- Type *exprtype = expr->rtype;
-
- if (copts.altivec_model && IS_TYPE_VECTOR(type) && IS_TYPE_VECTOR(exprtype) && TYPE_STRUCT(type)->stype == TYPE_STRUCT(exprtype)->stype)
+ const Type *exprtype = expr->rtype;
+
+ if (
+ copts.altivec_model &&
+ IS_TYPE_VECTOR(type) &&
+ IS_TYPE_VECTOR(exprtype) &&
+ TYPE_STRUCT(type)->stype == TYPE_STRUCT(exprtype)->stype
+ )
result = CheckResult3;
else
result = CheckResult0;
diff --git a/compiler_and_linker/unsorted/CodeGenOptPPC.c b/compiler_and_linker/unsorted/CodeGenOptPPC.c
index 5723395..4964435 100644
--- a/compiler_and_linker/unsorted/CodeGenOptPPC.c
+++ b/compiler_and_linker/unsorted/CodeGenOptPPC.c
@@ -1,17 +1,120 @@
#include "compiler/CodeGenOptPPC.h"
#include "compiler/InstrSelection.h"
+#include "compiler/CCompiler.h"
+#include "pref_structs.h"
+#include "compiler/CParser.h"
+
+static short pref_versions;
void CodeGen_InitCompiler(void) {
init_cgdispatch();
}
void CodeGen_TermCompiler(void) {
-
+ // empty!
}
void CodeGen_InitBackEndOptions(void) {
- // TODO
+ Handle handle;
+ PBackEnd pb;
+ PMachOLinker pmol;
+
+ CWSecretGetNamedPreferences(cparams.context, "PPC CodeGen Mach-O", &handle);
+ pb = *((PBackEnd *) *handle);
+ pref_versions = pb.version;
+
+ CWSecretGetNamedPreferences(cparams.context, "PPC Mach-O Linker", &handle);
+ pmol = *((PMachOLinker *) *handle);
+
+ copts.code_alignment = 16;
+ copts.misaligned_mem_access = 1;
+ copts.switch_tables = 1;
+ copts.prepare_compress = 0;
+ copts.some_alignment = 4;
+ copts.altivec_model = 0;
+ copts.altivec_vrsave = 1;
+ copts.codegen_pic = pb.pic;
+ copts.codegen_dynamic = pb.dynamic;
+ if (!copts.codegen_dynamic)
+ copts.codegen_pic = 0;
+ copts.no_common = !pb.common;
+ copts.no_implicit_templates = 0;
+ copts.absolutepath = pmol.symfullpath;
+ copts.x06 = pmol.exports;
+ copts.schedule_mode = 2;
+ copts.altivec_model = pb.altivec;
+ copts.readonly_strings = pb.readonlystrings;
+ if (pb.schedule)
+ copts.schedule_mode = 2;
+ else
+ copts.schedule_mode = 0;
+
+ switch (pb.processor) {
+ case 1:
+ copts.cpu = CPU_PPC601;
+ copts.schedule_cpu = 1;
+ break;
+ case 2:
+ copts.cpu = CPU_PPC603;
+ copts.schedule_cpu = 2;
+ break;
+ case 3:
+ copts.cpu = CPU_PPC603e;
+ copts.schedule_cpu = 5;
+ break;
+ case 4:
+ copts.cpu = CPU_PPC604;
+ copts.schedule_cpu = 3;
+ break;
+ case 5:
+ copts.cpu = CPU_PPC604e;
+ copts.schedule_cpu = 6;
+ break;
+ case 6:
+ copts.cpu = CPU_PPC750;
+ copts.schedule_cpu = 4;
+ break;
+ case 7:
+ copts.cpu = CPU_PPC7400;
+ copts.schedule_cpu = 7;
+ break;
+ case 8:
+ copts.cpu = CPU_PPC7450;
+ copts.schedule_cpu = 10;
+ break;
+ default:
+ copts.cpu = CPU_Generic;
+ copts.schedule_cpu = 8;
+ break;
+ }
+
+ copts.peephole = pb.peephole;
+ copts.align_mode = pb.structalignment;
+ copts.profile = pb.profiler;
+ copts.fp_contract = pb.fpcontract;
+ copts.traceback = pb.tracebacktables > 0;
+ copts.x1D = pb.tracebacktables == 2;
+ copts.x1E = 0;
+ if (pb.processorspecific && copts.cpu >= CPU_PPC603)
+ copts.gen_fsel = 10;
+ else
+ copts.gen_fsel = 0;
+ if (pb.vrsave)
+ copts.altivec_vrsave = 1;
+ else
+ copts.altivec_vrsave = 0;
+ copts.ppc_unroll_speculative = 1;
+ copts.ppc_unroll_instructions_limit = 70;
+ copts.ppc_unroll_factor_limit = 10;
+ copts.ppc_opt_bclr_bcctr = 1;
+ copts.use_lmw_stmw = 1;
+ if (copts.optimizationlevel > 2)
+ copts.optimizewithasm = 1;
+ else
+ copts.optimizewithasm = 0;
+ copts.opt_strength_reduction_strict = 1;
}
void Test_Version_Numbers(void) {
+ // empty!
}
diff --git a/compiler_and_linker/unsorted/Exceptions.c b/compiler_and_linker/unsorted/Exceptions.c
index 80d0cc4..cd25577 100644
--- a/compiler_and_linker/unsorted/Exceptions.c
+++ b/compiler_and_linker/unsorted/Exceptions.c
@@ -553,7 +553,7 @@ static UInt32 findPC_long(PCode *instr) {
return pc;
}
-static void initializeexceptiontables(void) {
+void initializeexceptiontables(void) {
int i;
for (i = 0; i < EAT_NACTIONS; i++)
@@ -737,7 +737,7 @@ void recordexceptionactions(PCode *instr, ExceptionAction *actions) {
}
}
-void deleteexceptionaction(PCAction *pca) {
+static void deleteexceptionaction(PCAction *pca) {
if (pca->prev)
pca->prev->next = pca->next;
else
diff --git a/compiler_and_linker/unsorted/FuncLevelAsmPPC.c b/compiler_and_linker/unsorted/FuncLevelAsmPPC.c
index a1ea8cc..e7fe347 100644
--- a/compiler_and_linker/unsorted/FuncLevelAsmPPC.c
+++ b/compiler_and_linker/unsorted/FuncLevelAsmPPC.c
@@ -119,7 +119,7 @@ static void FuncAsm_PreScanDirectives(void) {
cprep_eoltokens = 1;
if (setjmp(InlineAsm_assemblererror) == 0) {
- while (tk == TK_IDENTIFIER && (directive = InlineAsm_IsDirective(1))) {
+ while (tk == TK_IDENTIFIER && (directive = InlineAsm_IsDirective(AssemblerType_0))) {
InlineAsm_ProcessDirective(directive);
if (tk == ';' || tk == TK_NEG7) {
diff --git a/compiler_and_linker/unsorted/GCCInlineAsm.c b/compiler_and_linker/unsorted/GCCInlineAsm.c
index 9bceb19..d0ae953 100644
--- a/compiler_and_linker/unsorted/GCCInlineAsm.c
+++ b/compiler_and_linker/unsorted/GCCInlineAsm.c
@@ -1,33 +1,230 @@
#include "compiler/GCCInlineAsm.h"
+#include "compiler/CError.h"
+#include "compiler/CExpr.h"
+#include "compiler/CFunc.h"
+#include "compiler/CInt64.h"
+#include "compiler/CParser.h"
+#include "compiler/CPrep.h"
+#include "compiler/CPrepTokenizer.h"
+#include "compiler/InlineAsm.h"
+#include "compiler/objects.h"
Statement *first_ST_ASM;
+IALookupResult gcc_name_list[20];
+int gcc_name_list_index;
-void InlineAsm_SkipComment() {
+void InlineAsm_SkipComment(void) {
+ while (1) {
+ if (tk != '/')
+ break;
+ if (lookahead() != '*')
+ break;
+
+ tk = lex();
+ while (!((tk = lex()) == '*' && (tk = lex()) == '/')) {
+ // nothing
+ }
+ tk = lex();
+ }
}
-static void gcc_parse_attribute() {
+static char gcc_parse_attribute(void) {
+ char ch;
+
+ while (tk == TK_NEG7)
+ tk = lex();
+
+ if (tk != '"')
+ CError_Error(CErrorStr105);
+
+ while ((tk = lex()) != TK_IDENTIFIER) {
+ // nothing
+ }
+
+ ch = tkidentifier->name[0];
+
+ if ((tk = lex()) != '"')
+ CError_Error(CErrorStr105);
+ tk = lex();
+
+ return ch;
}
-static void gcc_parse_name() {
+static void gcc_parse_name(Boolean flag, char attribute) {
+ IALookupResult *nameentry;
+ ENode *expr;
+ Object *tempobj;
+ ENode *tempexpr;
+ Statement *stmt;
+
+ while (tk == TK_NEG7)
+ tk = lex();
+
+ if (tk != '(')
+ CError_Error(CErrorStr114);
+
+ tk = lex();
+
+ if (flag) {
+ if (tk != TK_IDENTIFIER)
+ CError_Error(CErrorStr105);
+
+ InlineAsm_LookupSymbol(tkidentifier, &gcc_name_list[++gcc_name_list_index]);
+ if (gcc_name_list[gcc_name_list_index].object && gcc_name_list[gcc_name_list_index].object->u.var.info)
+ gcc_name_list[gcc_name_list_index].object->u.var.info->used = 1;
+
+ tk = lex();
+ } else {
+ in_assembler = 0;
+ cprep_nostring = 0;
+ nameentry = &gcc_name_list[++gcc_name_list_index];
+
+ expr = expression();
+ if (attribute == 'i' || attribute == 'I') {
+ if (!ENODE_IS(expr, EINTCONST))
+ CError_Error(CErrorStr144);
+ nameentry->value = CInt64_GetULong(&expr->data.intval);
+ nameentry->has_value = 1;
+ } else {
+ tempobj = create_temp_object(expr->rtype);
+ tempexpr = create_objectnode(tempobj);
+ if (tempobj->u.var.info)
+ tempobj->u.var.info->used = 1;
+ expr = makediadicnode(tempexpr, expr, EASS);
+
+ stmt = CFunc_InsertBeforeStatement(ST_EXPRESSION, first_ST_ASM);
+ first_ST_ASM = stmt->next;
+ if (!first_ST_ASM->next)
+ curstmt = first_ST_ASM;
+ stmt->expr = expr;
+
+ nameentry->name = tempobj->name;
+ nameentry->object = tempobj;
+ nameentry->label = NULL;
+ nameentry->type = NULL;
+ nameentry->has_value = 0;
+ }
+ }
+
+ cprep_nostring = 1;
+ in_assembler = 1;
+
+ if (tk != ')')
+ CError_Error(CErrorStr115);
+ tk = lex();
}
-static void gcc_parse_expression() {
+static void gcc_parse_expression(Boolean flag) {
+ while (1) {
+ gcc_parse_name(flag, gcc_parse_attribute());
+ if (tk != ',')
+ break;
+ tk = lex();
+ }
}
-static void gcc_parse_input() {
+static void gcc_parse_input(void) {
+ if (tk == ':') {
+ if ((tk = lex()) == ':' || tk == ')' || tk == '}')
+ return;
+ gcc_parse_expression(0);
+ }
}
-static void gcc_parse_output() {
+static void gcc_parse_output(void) {
+ if (tk == ':') {
+ if ((tk = lex()) == ':' || tk == ')' || tk == '}')
+ return;
+ gcc_parse_expression(1);
+ }
}
-static void gcc_parse_killed() {
+static void gcc_parse_killed(void) {
+ if (tk == ':') {
+ while (1) {
+ if ((tk = lex()) != '"')
+ return;
+
+ tk = lex();
+ while (1) {
+ if (tk == '"') {
+ if (lookahead() == ',') {
+ tk = lex();
+ break;
+ }
+ tk = lex();
+ return;
+ }
+ tk = lex();
+ }
+ }
+ }
}
-static void gcc_replace_arg_st_asm() {
+static void gcc_replace_arg_st_asm(Statement *stmt) {
+ InlineAsm *ia;
+ int i;
+ IAOperand *op;
+ short effect;
+ short rclass;
+ SInt32 num;
+
+ if ((ia = (InlineAsm *) stmt->expr)) {
+ for (i = 0, op = ia->args; i < ia->argcount; i++, op++) {
+ switch (op->type) {
+ case IAOpnd_Imm:
+ case IAOpnd_Reg:
+ case IAOpnd_3:
+ case IAOpnd_4:
+ case IAOpnd_Lab:
+ break;
+
+ case IAOpnd_6:
+ if (op->u.unk6.unk4 == 2) {
+ effect = op->u.unk6.effect;
+ rclass = op->u.unk6.rclass;
+ num = op->u.unk6.num;
+ op->type = IAOpnd_Reg;
+ op->u.reg.effect = effect;
+ op->u.reg.rclass = rclass;
+ op->u.reg.object = NULL;
+ if (num <= gcc_name_list_index)
+ op->u.reg.object = gcc_name_list[num].object;
+ else
+ CError_Error(CErrorStr144);
+ op->u.reg.num = 0;
+ } else {
+ CError_FATAL(365);
+ }
+ break;
+
+ case IAOpnd_7:
+ op->type = IAOpnd_Imm;
+ op->u.imm.value = gcc_name_list[op->u.unk7.value].value;
+ break;
+ }
+ }
+ }
}
-static void gcc_replace_arg() {
+static void gcc_replace_arg(void) {
+ Statement *stmt;
+
+ for (stmt = first_ST_ASM; stmt; stmt = stmt->next) {
+ if (stmt->type == ST_ASM)
+ gcc_replace_arg_st_asm(stmt);
+ }
}
void InlineAsm_gcc_parse(void) {
+ gcc_name_list_index = -1;
+ cprep_eoltokens = 0;
+
+ if (tk == TK_NEG7)
+ tk = lex();
+
+ gcc_parse_output();
+ gcc_parse_input();
+ gcc_parse_killed();
+ gcc_replace_arg();
}
diff --git a/compiler_and_linker/unsorted/InlineAsm.c b/compiler_and_linker/unsorted/InlineAsm.c
index 628c678..e800327 100644
--- a/compiler_and_linker/unsorted/InlineAsm.c
+++ b/compiler_and_linker/unsorted/InlineAsm.c
@@ -591,7 +591,7 @@ Object *InlineAsm_GetObjectOffset(InlineAsm *ia, SInt32 index, SInt32 *offset) {
for (i = 0, counter = 0, op = ia->args; i < ia->argcount; i++, op++) {
if (op->type == IAOpnd_3) {
if (counter++ == index) {
- *offset = ((SInt32) &op->u.obj.obj) - ((SInt32) ia);
+ *offset = ((intptr_t) &op->u.obj.obj) - ((intptr_t) ia);
return op->u.obj.obj;
}
}
diff --git a/compiler_and_linker/unsorted/InlineAsmPPC.c b/compiler_and_linker/unsorted/InlineAsmPPC.c
index 19c8fdc..e3a5f98 100644
--- a/compiler_and_linker/unsorted/InlineAsmPPC.c
+++ b/compiler_and_linker/unsorted/InlineAsmPPC.c
@@ -1,32 +1,29 @@
#include "compiler/InlineAsmPPC.h"
#include "compiler/CError.h"
+#include "compiler/CExpr.h"
#include "compiler/CInt64.h"
#include "compiler/CFunc.h"
#include "compiler/CMachine.h"
#include "compiler/CParser.h"
#include "compiler/CPrep.h"
#include "compiler/CPrepTokenizer.h"
-#include "compiler/TOC.h"
+#include "compiler/Alias.h"
+#include "compiler/CodeGen.h"
+#include "compiler/CodeGenOptPPC.h"
+#include "compiler/CompilerTools.h"
+#include "compiler/Exceptions.h"
#include "compiler/FuncLevelAsmPPC.h"
#include "compiler/InlineAsm.h"
#include "compiler/InlineAsmMnemonicsPPC.h"
#include "compiler/InlineAsmRegisters.h"
#include "compiler/InlineAsmRegistersPPC.h"
-#include "compiler/CodeGen.h"
-#include "compiler/CodeGenOptPPC.h"
-#include "compiler/PPCError.h"
-#include "compiler/RegisterInfo.h"
-#include "compiler/objects.h"
-#include "compiler/CExpr.h"
#include "compiler/PCode.h"
#include "compiler/PCodeUtilities.h"
+#include "compiler/PPCError.h"
+#include "compiler/RegisterInfo.h"
#include "compiler/StackFrame.h"
-#include "compiler/CompilerTools.h"
-#include "compiler/Alias.h"
-
-// TODO: move me
-extern int countexceptionactionregisters(ExceptionAction *);
-extern void noteexceptionactionregisters(ExceptionAction *, PCodeArg *);
+#include "compiler/TOC.h"
+#include "compiler/objects.h"
char asm_alloc_flags[10];
Section sm_section;
@@ -35,17 +32,12 @@ SInt32 fralloc_parameter_area_size;
Boolean user_responsible_for_frame;
Boolean supports_hardware_fpu;
UInt32 assembledinstructions;
-UInt8 assembler_type;
+AssemblerType assembler_type;
char volatileasm;
Boolean InlineAsm_gccmode;
Boolean InlineAsm_labelref;
CLabel *pic_base_label;
-enum {
- NO_REG = 0,
- INVALID_PIC_REG = -2
-};
-
// forward decls
static SInt32 InlineAsm_ConstantExpressionPPC(SInt32 value);
static Object *isvariableoperand(void);
@@ -71,8 +63,9 @@ static void IllegalObjectOperator(HashNameNode *name1, HashNameNode *name2, shor
case TK_SHR: opstr = ">>"; break;
case '<': opstr = "<"; break;
case '>': opstr = ">"; break;
- case TK_LESS_EQUAL: opstr = "<="; break;
- case TK_GREATER_EQUAL: opstr = ">="; break;
+ // bug? these two seem swapped
+ case TK_LESS_EQUAL: opstr = ">="; break;
+ case TK_GREATER_EQUAL: opstr = "<="; break;
case TK_LOGICAL_EQ: opstr = "=="; break;
case TK_LOGICAL_NE: opstr = "!="; break;
case '&': opstr = "&"; break;
@@ -1478,7 +1471,7 @@ static int mnemonic_has_overflow(char *buf) {
return result;
}
-static int mnemonic_has_absolute(char *buf) {
+static int mnemonic_has_absolute(const char *buf) {
int result = 0;
char last = buf[strlen(buf) - 1];
@@ -1488,7 +1481,7 @@ static int mnemonic_has_absolute(char *buf) {
return result;
}
-static int mnemonic_has_linkregister(char *buf) {
+static int mnemonic_has_linkregister(const char *buf) {
int result = 0;
char last = buf[strlen(buf) - 1];
@@ -1552,7 +1545,7 @@ void InlineAsm_InitializePPC(void) {
cpu |= 0x40000000;
}
-void InlineAsm_Initialize(UInt8 assemblertype) {
+void InlineAsm_Initialize(AssemblerType assemblertype) {
assembler_type = assemblertype;
if (assembler_type == 0) {
@@ -1608,7 +1601,7 @@ static InlineAsm *InlineAsm_CreateFrFree(void) {
return ia;
}
-SInt32 InlineAsm_IsDirective(UInt8 assemblertype) {
+SInt32 InlineAsm_IsDirective(AssemblerType assemblertype) {
char *name;
SInt32 directive = IADirective_Null;
@@ -1619,7 +1612,7 @@ SInt32 InlineAsm_IsDirective(UInt8 assemblertype) {
name = tkidentifier->name;
if (!strcmp(name, "machine")) {
directive = IADirective_Machine;
- } else if (assemblertype == 1) {
+ } else if (assemblertype == AssemblerType_1) {
if (!strcmp(name, "entry")) {
directive = IADirective_Entry;
} else if (!strcmp(name, "fralloc")) {
@@ -1815,6 +1808,7 @@ void InlineAsm_ScanAssemblyInstruction(void) {
Boolean flag1;
Boolean flag2;
SInt32 directive;
+ OpcodeInfo *info;
char buf[20];
flag1 = 0;
@@ -1837,9 +1831,10 @@ void InlineAsm_ScanAssemblyInstruction(void) {
if (!mnemonic)
CError_Error(CErrorStr261);
- flag3 = (FLAG_SET_F(opcodeinfo[mnemonic->x4].flags) & fPCodeFlag4000000) && (mnemonic->x10 & 0x400);
- flag4 = (FLAG_SET_T(opcodeinfo[mnemonic->x4].flags) & fPCodeFlag20000000) && (mnemonic->x10 & 2);
- flag5 = (FLAG_SET_T(opcodeinfo[mnemonic->x4].flags) & fPCodeFlag2000000) && (mnemonic->x10 & 1);
+ info = &opcodeinfo[mnemonic->x4];
+ flag3 = (FLAG_SET_F(info->flags) & fPCodeFlag4000000) && (mnemonic->x10 & 0x400);
+ flag4 = (FLAG_SET_T(info->flags) & fPCodeFlag20000000) && (mnemonic->x10 & 2);
+ flag5 = (FLAG_SET_T(info->flags) & fPCodeFlag2000000) && (mnemonic->x10 & 1);
if ((cpu == CPUMask_Generic) && (cpu & CPUFLAG_LOW_MASK) != ((cpu & mnemonic->cpu) & CPUFLAG_LOW_MASK)) {
CError_Error(CErrorStr152);
@@ -1901,8 +1896,7 @@ void InlineAsm_ScanAssemblyInstruction(void) {
++assembledinstructions;
}
-static PCode *InlineAsm_TranslateIRtoPCodePPC(InlineAsm *ia, int argcount, UInt8 assemblertype) {
- OpcodeInfo *info;
+static PCode *InlineAsm_TranslateIRtoPCodePPC(InlineAsm *ia, int argcount, AssemblerType assemblertype) {
PCode *pc;
int index;
int extra_args;
@@ -1911,6 +1905,7 @@ static PCode *InlineAsm_TranslateIRtoPCodePPC(InlineAsm *ia, int argcount, UInt8
SInt32 buffersize;
IAOperand *src;
PCodeArg *dest;
+ OpcodeInfo *info;
info = &opcodeinfo[ia->opcode];
index = 0;
@@ -2106,7 +2101,7 @@ static PCode *InlineAsm_TranslateIRtoPCodePPC(InlineAsm *ia, int argcount, UInt8
dest->kind = PCOp_REGISTER;
dest->arg = RegClass_GPR;
dest->data.reg.reg = i;
- dest->data.reg.effect = (short) ((ia->opcode == PC_LMW) ? EffectWrite : EffectRead);
+ dest->data.reg.effect = ((ia->opcode == PC_LMW) ? EffectWrite : EffectRead);
}
}
@@ -2485,8 +2480,8 @@ void CodeGen_GetAsmEffects(Statement *stmt, IAEffects *effects) {
CError_FATAL(4087);
}
- CError_ASSERT(4090, effects->numoperands <= 16);
- CError_ASSERT(4093, effects->numlabels <= 16);
+ CError_ASSERT(4090, (UInt32) effects->numoperands <= IAMaxOperands);
+ CError_ASSERT(4093, (UInt32) effects->numlabels <= IAMaxLabels);
}
for (i = 0, op = ia->args; i < ia->argcount; i++, op++) {
@@ -2526,7 +2521,7 @@ void CodeGen_GetAsmEffects(Statement *stmt, IAEffects *effects) {
break;
}
- CError_ASSERT(4151, effects->numoperands <= 16);
+ CError_ASSERT(4151, (UInt32) effects->numoperands <= IAMaxOperands);
}
if ((info->flags & (fPCodeFlag1 | fPCodeFlag8)) && (SInt32)effects->numlabels == 0)
diff --git a/compiler_and_linker/unsorted/InstrSelection.c b/compiler_and_linker/unsorted/InstrSelection.c
index ac60baf..1916711 100644
--- a/compiler_and_linker/unsorted/InstrSelection.c
+++ b/compiler_and_linker/unsorted/InstrSelection.c
@@ -4,20 +4,20 @@
#include "compiler/CMachine.h"
#include "compiler/CParser.h"
#include "compiler/CodeGen.h"
+#include "compiler/CompilerTools.h"
+#include "compiler/FunctionCalls.h"
+#include "compiler/Intrinsics.h"
#include "compiler/Operands.h"
#include "compiler/PCode.h"
#include "compiler/PCodeInfo.h"
#include "compiler/PCodeUtilities.h"
#include "compiler/RegisterInfo.h"
+#include "compiler/StructMoves.h"
#include "compiler/TOC.h"
-#include "compiler/CompilerTools.h"
#include "compiler/enode.h"
#include "compiler/objects.h"
#include "compiler/types.h"
-// TODO: move me
-extern void move_block(Operand *, Operand *, SInt32, SInt32);
-
PrecomputedOperand *precomputedoperands;
void (*cgdispatch[MAXEXPR + 1])(ENode *, short, short, Operand *);
@@ -103,8 +103,7 @@ void gen_DEFINE(ENode *expr, short outputReg, short outputRegHi, Operand *output
void gen_REUSE(ENode *expr, short outputReg, short outputRegHi, Operand *output) {
ENode *inner = expr->data.monadic;
-#line 250
- CError_ASSERT(ENODE_IS(inner, EDEFINE));
+ CError_ASSERT(250, ENODE_IS(inner, EDEFINE));
gen_DEFINE(inner, outputReg, outputRegHi, output);
}
@@ -250,8 +249,7 @@ void gen_INDIRECT(ENode *expr, short outputReg, short outputRegHi, Operand *outp
output->optype = OpndType_CRField;
break;
default:
-#line 456
- CError_FATAL();
+ CError_FATAL(456);
}
output->reg = vi->reg;
output->object = NULL;
@@ -386,8 +384,7 @@ void gen_FORCELOAD(ENode *expr, short outputReg, short outputRegHi, Operand *out
else
ENSURE_GPR(output, inner->rtype, outputReg);
} else if (!IS_TYPE_VOID(inner->rtype)) {
-#line 681
- CError_FATAL();
+ CError_FATAL(681);
}
}
@@ -1114,8 +1111,7 @@ void gen_ASS(ENode *expr, short outputReg, short outputRegHi, Operand *output) {
if (ENODE_IS(left, EINDIRECT)) {
left = left->data.monadic;
} else {
-#line 1759
- CError_FATAL();
+ CError_FATAL(1759);
}
right = expr->data.cond.expr2;
} else {
@@ -1149,8 +1145,7 @@ void gen_ASS(ENode *expr, short outputReg, short outputRegHi, Operand *output) {
output->optype = OpndType_VR;
break;
default:
-#line 1810
- CError_FATAL();
+ CError_FATAL(1810);
}
if (opright.reg != vi->reg) {
PCodeArg a, b;
@@ -1382,14 +1377,12 @@ void gen_TYPCON(ENode *expr, short outputReg, short outputRegHi, Operand *output
} else if (srctype->size == dsttype->size) {
GEN_NODE_TO_REG(inner, outputReg, 0, output);
} else {
-#line 2224
- CError_FATAL();
+ CError_FATAL(2224);
}
}
void gen_BITFIELD(ENode *expr, short outputReg, short outputRegHi, Operand *output) {
-#line 2238
- CError_FATAL();
+ CError_FATAL(2238);
}
void gen_INTCONST(ENode *expr, short outputReg, short outputRegHi, Operand *output) {
@@ -1403,13 +1396,11 @@ void gen_INTCONST(ENode *expr, short outputReg, short outputRegHi, Operand *outp
}
void gen_FLOATCONST(ENode *expr, short outputReg, short outputRegHi, Operand *output) {
-#line 2294
- CError_FATAL();
+ CError_FATAL(2294);
}
void gen_STRINGCONST(ENode *expr, short outputReg, short outputRegHi, Operand *output) {
-#line 2308
- CError_FATAL();
+ CError_FATAL(2308);
}
static Boolean COND_is_ABS_MatchNodes(ENode *cond, ENode *expr1, ENode *expr2) {
@@ -1619,6 +1610,8 @@ void gen_COND(ENode *expr, short outputReg, short outputRegHi, Operand *output)
Boolean flag;
Operand op;
int fneg_reg;
+ int fneg_reg2;
+ int fneg_reg3;
int fsel_reg;
int final_reg;
@@ -1648,8 +1641,7 @@ void gen_COND(ENode *expr, short outputReg, short outputRegHi, Operand *output)
right = tmp;
break;
default:
-#line 2780
- CError_FATAL();
+ CError_FATAL(2780);
}
if (ENODE_IS(left, EFLOATCONST) && CMach_FloatIsZero(left->data.floatval)) {
@@ -1680,12 +1672,12 @@ void gen_COND(ENode *expr, short outputReg, short outputRegHi, Operand *output)
GEN_NODE_TO_FPR(expr1, &op1, expr1->rtype, 0);
GEN_NODE_TO_FPR(expr2, &op2, expr2->rtype, 0);
- fneg_reg = ALLOC_FPR();
- emitpcode(PC_FNEG, fneg_reg, op.reg);
+ fneg_reg2 = ALLOC_FPR();
+ emitpcode(PC_FNEG, fneg_reg2, op.reg);
fsel_reg = ALLOC_FPR();
emitpcode(PC_FSEL, fsel_reg, op.reg, op1.reg, op2.reg);
final_reg = outputReg ? outputReg : ALLOC_FPR();
- emitpcode(PC_FSEL, final_reg, fneg_reg, fsel_reg, op2.reg);
+ emitpcode(PC_FSEL, final_reg, fneg_reg2, fsel_reg, op2.reg);
}
break;
case ELESS:
@@ -1695,18 +1687,17 @@ void gen_COND(ENode *expr, short outputReg, short outputRegHi, Operand *output)
GEN_NODE_TO_FPR(expr1, &op1, expr1->rtype, 0);
GEN_NODE_TO_FPR(expr2, &op2, expr2->rtype, 0);
- fneg_reg = op.reg;
+ fneg_reg3 = op.reg;
if (flag) {
- fneg_reg = ALLOC_FPR();
- emitpcode(PC_FNEG, fneg_reg, op.reg);
+ fneg_reg3 = ALLOC_FPR();
+ emitpcode(PC_FNEG, fneg_reg3, op.reg);
}
final_reg = outputReg ? outputReg : ALLOC_FPR();
- emitpcode(PC_FSEL, final_reg, fneg_reg, op1.reg, op2.reg);
+ emitpcode(PC_FSEL, final_reg, fneg_reg3, op1.reg, op2.reg);
break;
default:
-#line 2862
- CError_FATAL();
+ CError_FATAL(2862);
}
output->optype = OpndType_FPR;
@@ -1814,8 +1805,7 @@ void gen_COND(ENode *expr, short outputReg, short outputRegHi, Operand *output)
ENSURE_GPR(&op1, expr1->rtype, 0);
emitpcode(PC_AND, reg1, op1.reg, isel_op1.reg);
} else {
-#line 3119
- CError_FATAL();
+ CError_FATAL(3119);
}
output->optype = OpndType_GPR;
@@ -1851,8 +1841,7 @@ void gen_COND(ENode *expr, short outputReg, short outputRegHi, Operand *output)
return;
default:
-#line 3168
- CError_FATAL();
+ CError_FATAL(3168);
}
}
@@ -2157,9 +2146,8 @@ void gen_CONDASS(ENode *expr, short outputReg, short outputRegHi, Operand *outpu
flag = 0;
memclrw(&op, sizeof(Operand));
-#line 3704
- CError_ASSERT(ENODE_IS(expr1, EINDIRECT));
- CError_ASSERT(ENODE_IS(expr1->data.monadic, EOBJREF));
+ CError_ASSERT(3704, ENODE_IS(expr1, EINDIRECT));
+ CError_ASSERT(3705, ENODE_IS(expr1->data.monadic, EOBJREF));
tmpreg = OBJECT_REG(expr1->data.monadic->data.objref);
final_reg = outputReg ? tmpreg : ALLOC_FPR();
@@ -2187,8 +2175,7 @@ void gen_CONDASS(ENode *expr, short outputReg, short outputRegHi, Operand *outpu
flag2 = 0;
break;
default:
-#line 3744
- CError_FATAL();
+ CError_FATAL(3744);
}
if (ENODE_IS(left, EFLOATCONST) && CMach_FloatIsZero(left->data.floatval)) {
@@ -2251,8 +2238,7 @@ void gen_CONDASS(ENode *expr, short outputReg, short outputRegHi, Operand *outpu
emitpcode(PC_FSEL, final_reg, fneg_reg, op2.reg, op1.reg);
break;
default:
-#line 2862
- CError_FATAL();
+ CError_FATAL(2862);
}
if (op3.optype != OpndType_FPR)
@@ -2270,10 +2256,8 @@ void gen_CONDASS(ENode *expr, short outputReg, short outputRegHi, Operand *outpu
ENode *abs_expr;
memclrw(&isel_op, sizeof(Operand));
-#line 3966
- CError_ASSERT(ENODE_IS(expr1, EINDIRECT));
-#line 3968
- CError_ASSERT(ENODE_IS(expr1->data.monadic, EOBJREF));
+ CError_ASSERT(3966, ENODE_IS(expr1, EINDIRECT));
+ CError_ASSERT(3968, ENODE_IS(expr1->data.monadic, EOBJREF));
if (CONDASS_is_ABS(cond, expr1, expr2)) {
if (ENODE_IS(cond->data.diadic.left, EASS))
@@ -2282,14 +2266,12 @@ void gen_CONDASS(ENode *expr, short outputReg, short outputRegHi, Operand *outpu
GEN_NODE(cond->data.diadic.right, &isel_op);
outputReg = OBJECT_REG(expr1->data.monadic->data.objref);
-#line 3979
- CError_ASSERT(outputReg);
+ CError_ASSERT(3979, outputReg);
GEN_NODE(expr1, &op1);
op3 = op1;
-#line 3986
- CError_ASSERT(op3.optype == OpndType_GPR && op3.reg == outputReg);
+ CError_ASSERT(3986, op3.optype == OpndType_GPR && op3.reg == outputReg);
ENSURE_GPR(&op1, expr1->rtype, 0);
if (expr1->rtype->size < 4)
@@ -2317,6 +2299,10 @@ void gen_CONDASS(ENode *expr, short outputReg, short outputRegHi, Operand *outpu
}
void gen_FUNCCALL(ENode *expr, short outputReg, short outputRegHi, Operand *output) {
+ if (is_intrinsic_function_call(expr))
+ call_intrinsic_function(expr, outputReg, output);
+ else
+ call_function(expr, output);
}
void gen_OBJREF(ENode *expr, short outputReg, short outputRegHi, Operand *output) {
@@ -2324,8 +2310,7 @@ void gen_OBJREF(ENode *expr, short outputReg, short outputRegHi, Operand *output
}
void gen_UNEXPECTED(ENode *expr, short outputReg, short outputRegHi, Operand *output) {
-#line 4160
- CError_FATAL();
+ CError_FATAL(4160);
}
static int small(ENode *expr) {
@@ -2658,8 +2643,7 @@ void gen_LOGICAL(ENode *expr, short outputReg, short outputRegHi, Operand *outpu
tmpreg1 = ALLOC_GPR();
tmpreg2 = ALLOC_GPR();
-#line 4853
- CError_ASSERT(output->optype == OpndType_GPR);
+ CError_ASSERT(4853, output->optype == OpndType_GPR);
emitpcode(PC_CNTLZW, tmpreg2, output->reg);
emitpcode(PC_RLWINM, tmpreg1, tmpreg2, 27, 5, 31);
@@ -2685,8 +2669,7 @@ void gen_LOGICAL(ENode *expr, short outputReg, short outputRegHi, Operand *outpu
tmpreg1 = ALLOC_GPR();
tmpreg2 = ALLOC_GPR();
-#line 4883
- CError_ASSERT(output->optype == OpndType_GPR);
+ CError_ASSERT(4883, output->optype == OpndType_GPR);
emitpcode(PC_CNTLZW, tmpreg2, output->reg);
emitpcode(PC_RLWINM, tmpreg1, tmpreg2, 27, 5, 31);
@@ -2810,8 +2793,7 @@ void logical_expression(ENode *cond, PCodeLabel *if_true, PCodeLabel *if_false,
branch_conditional(op.reg, op.regOffset, 1, if_true);
break;
default:
-#line 5160
- CError_FATAL();
+ CError_FATAL(5160);
}
}
@@ -2829,8 +2811,7 @@ static void logical_expression_nobranch(ENode *cond, Boolean invert, Operand *ou
case ENOTEQU:
if (invert) {
ENodeType nt = invert_relop(cond->type);
-#line 5190
- CError_ASSERT(nt != cond->type);
+ CError_ASSERT(5190, nt != cond->type);
cond->type = nt;
}
@@ -2841,8 +2822,7 @@ static void logical_expression_nobranch(ENode *cond, Boolean invert, Operand *ou
break;
default:
-#line 5206
- CError_FATAL();
+ CError_FATAL(5206);
}
}
@@ -2999,8 +2979,7 @@ void gen_condition_gpr(ENode *cond, Operand *output, short outputReg) {
pc->args[1].data.reg.reg,
(r6 + r7 + 1) & 31, 31, 31);
} else {
-#line 5434
- CError_FATAL();
+ CError_FATAL(5434);
}
output->optype = OpndType_GPR;
output->reg = reg;
@@ -3061,8 +3040,7 @@ void gen_condition_gpr(ENode *cond, Operand *output, short outputReg) {
(r6 + r7 + 1) & 31, 31, 31);
emitpcode(PC_XORI, reg, tmpreg, 1);
} else {
-#line 5503
- CError_FATAL();
+ CError_FATAL(5503);
}
output->optype = OpndType_GPR;
output->reg = reg;
@@ -3265,8 +3243,7 @@ void gen_condition_gpr(ENode *cond, Operand *output, short outputReg) {
}
default:
-#line 5777
- CError_FATAL();
+ CError_FATAL(5777);
}
}
@@ -3589,8 +3566,7 @@ void I8_gen_ADD(ENode *expr, short outputReg, short outputRegHi, Operand *output
case 1 + 8:
case 2 + 8:
case 4 + 8:
-#line 6933
- CError_ASSERT(skipleft == 8);
+ CError_ASSERT(6933, skipleft == 8);
if (!is_uns) {
tmpreg2 = ALLOC_GPR();
emitpcode(PC_SRAWI, tmpreg2, opright.reg, 31);
@@ -3612,8 +3588,7 @@ void I8_gen_ADD(ENode *expr, short outputReg, short outputRegHi, Operand *output
emitpcode(PC_ADDE, regHi, opleft.regHi, opright.regHi);
break;
default:
-#line 6979
- CError_FATAL();
+ CError_FATAL(6979);
}
output->optype = OpndType_GPRPair;
@@ -3745,8 +3720,7 @@ void I8_gen_SUB(ENode *expr, short outputReg, short outputRegHi, Operand *output
emitpcode(PC_SUBFE, regHi, opright.regHi, opleft.regHi);
break;
default:
-#line 7211
- CError_FATAL();
+ CError_FATAL(7211);
}
output->optype = OpndType_GPRPair;
@@ -3840,10 +3814,8 @@ int I8_log2n(UInt64 val) {
}
void I8_ShiftLeftImmediate(Operand opnd, SInt32 value, int is_unsigned, SInt32 size, short reg, short regHi) {
- if (opnd.reg == reg || opnd.regHi == regHi || opnd.reg == regHi || opnd.regHi == reg) {
-#line 7703
- CError_FATAL();
- }
+ if (opnd.reg == reg || opnd.regHi == regHi || opnd.reg == regHi || opnd.regHi == reg)
+ CError_FATAL(7703);
if (value < 32) {
emitpcode(PC_RLWINM, reg, opnd.reg, value, 0, 31 - value);
@@ -3860,8 +3832,7 @@ void I8_ShiftLeftImmediate(Operand opnd, SInt32 value, int is_unsigned, SInt32 s
emitpcode(PC_RLWINM, regHi, opnd.reg, value - 32, 0, 63 - value);
emitpcode(PC_LI, reg, 0);
} else {
-#line 7732
- CError_FATAL();
+ CError_FATAL(7732);
}
}
@@ -3871,10 +3842,8 @@ void I8_ShiftRightImmediate(Operand opnd, SInt32 value, int is_unsigned, short r
short tmpreg3;
short tmpreg4;
- if (opnd.reg == reg || opnd.regHi == regHi || opnd.reg == regHi || opnd.regHi == reg) {
-#line 7756
- CError_FATAL();
- }
+ if (opnd.reg == reg || opnd.regHi == regHi || opnd.reg == regHi || opnd.regHi == reg)
+ CError_FATAL(7756);
if (value < 32) {
emitpcode(PC_RLWINM, reg, opnd.reg, 32 - value, 0, 31);
@@ -3927,8 +3896,7 @@ void I8_ShiftRightImmediate(Operand opnd, SInt32 value, int is_unsigned, short r
emitpcode(PC_SRAWI, regHi, opnd.regHi, 31);
}
} else {
-#line 7866
- CError_FATAL();
+ CError_FATAL(7866);
}
}
@@ -3957,10 +3925,8 @@ void I8_gen_MUL(ENode *expr, short outputReg, short outputRegHi, Operand *output
skipleft = GetSizeSkip(left);
skipright = GetSizeSkip(right);
- if (ENODE_IS(right, EINTCONST) && ENODE_IS(left, EINTCONST)) {
-#line 7900
- CError_FATAL();
- }
+ if (ENODE_IS(right, EINTCONST) && ENODE_IS(left, EINTCONST))
+ CError_FATAL(7900);
if (ENODE_IS(left, EINTCONST))
leftval = left->data.intval.lo + (((SInt64) ((skipleft < 8) ? 0 : left->data.intval.hi)) << 32);
@@ -4066,8 +4032,7 @@ void I8_gen_MUL(ENode *expr, short outputReg, short outputRegHi, Operand *output
case 1 + 8:
case 2 + 8:
case 4 + 8:
-#line 8097
- CError_ASSERT(skipleft == 8);
+ CError_ASSERT(8097, skipleft == 8);
if (ENODE_IS(left, EINTCONST) && FITS_IN_SHORT2(left->data.intval.lo) && left->data.intval.hi == 0) {
emitpcode(PC_MULLI, reg, opright.reg, LOW_PART(left->data.intval.lo));
if (is_uns)
@@ -4143,8 +4108,7 @@ void I8_gen_MUL(ENode *expr, short outputReg, short outputRegHi, Operand *output
}
break;
default:
-#line 8218
- CError_FATAL();
+ CError_FATAL(8218);
}
}
@@ -4206,12 +4170,10 @@ void I8_gen_ASS(ENode *expr, short outputReg, short outputRegHi, Operand *output
type = expr->rtype;
if (ENODE_IS(expr, ECONDASS)) {
left = expr->data.cond.expr1;
- if (ENODE_IS(left, EINDIRECT)) {
+ if (ENODE_IS(left, EINDIRECT))
left = left->data.monadic;
- } else {
-#line 8328
- CError_FATAL();
- }
+ else
+ CError_FATAL(8238);
right = expr->data.cond.expr2;
} else {
left = expr->data.diadic.left;
@@ -4225,8 +4187,7 @@ void I8_gen_ASS(ENode *expr, short outputReg, short outputRegHi, Operand *output
vi = Registers_GetVarInfo(left->data.objref);
GEN_NODE_TO_REG(right, vi->reg, vi->regHi, &opright);
if (vi->rclass != RegClass_GPR) {
-#line 8348
- CError_FATAL();
+ CError_FATAL(8348);
} else {
coerce_to_register_pair(&opright, type, vi->reg, vi->regHi);
*output = opright;
@@ -4239,8 +4200,7 @@ void I8_gen_ASS(ENode *expr, short outputReg, short outputRegHi, Operand *output
coerce_to_register_pair(&opright, right->rtype, 0, 0);
if (ENODE_IS(left, EBITFIELD)) {
-#line 8376
- CError_FATAL();
+ CError_FATAL(8376);
} else {
GEN_NODE(left, &opleft);
indirect(&opleft, left);
@@ -4286,8 +4246,7 @@ void I8_gen_POSTINCDEC(ENode *expr, short outputReg, short outputRegHi, Operand
return;
}
-#line 8446
- CError_ASSERT(!ENODE_IS(inner, EBITFIELD));
+ CError_ASSERT(8446, !ENODE_IS(inner, EBITFIELD));
GEN_NODE(inner, &op1);
indirect(&op1, inner);
@@ -4329,8 +4288,7 @@ void I8_gen_INDIRECT(ENode *expr, short outputReg, short outputRegHi, Operand *o
output->optype = OpndType_FPR;
break;
default:
-#line 8511
- CError_FATAL();
+ CError_FATAL(8511);
}
output->reg = vi->reg;
@@ -4340,8 +4298,7 @@ void I8_gen_INDIRECT(ENode *expr, short outputReg, short outputRegHi, Operand *o
}
if (ENODE_IS(inner, EBITFIELD)) {
-#line 8529
- CError_FATAL();
+ CError_FATAL(8529);
return;
}
@@ -4430,8 +4387,7 @@ void I8_gen_condition(ENode *cond, Operand *output, int write_to_gpr) {
}
}
-#line 8704
- CError_ASSERT(opleft.optype == OpndType_GPRPair && opright.optype == OpndType_GPRPair);
+ CError_ASSERT(8704, opleft.optype == OpndType_GPRPair && opright.optype == OpndType_GPRPair);
switch (cond->type) {
case EEQU:
@@ -4525,8 +4481,7 @@ void I8_gen_condition(ENode *cond, Operand *output, int write_to_gpr) {
}
break;
default:
-#line 8814
- CError_FATAL();
+ CError_FATAL(8814);
}
}
@@ -4569,8 +4524,7 @@ void I8_gen_SHL_SHR(ENode *expr, short outputReg, short outputRegHi, Operand *ou
opright.optype = OpndType_GPR;
}
-#line 8890
- CError_ASSERT(opleft.optype == OpndType_GPRPair && opright.optype == OpndType_GPR);
+ CError_ASSERT(8890, opleft.optype == OpndType_GPRPair && opright.optype == OpndType_GPR);
if (opleft.regHi != high_reg)
emitpcode(PC_MR, high_reg, opleft.regHi);
@@ -4587,8 +4541,7 @@ void I8_gen_SHL_SHR(ENode *expr, short outputReg, short outputRegHi, Operand *ou
} else if (ENODE_IS(expr, ESHL)) {
branch_subroutine(rt_shl2i, 0, used_regs);
} else {
-#line 8909
- CError_FATAL();
+ CError_FATAL(8909);
}
emitpcode(PC_MR, output->reg, low_reg);
@@ -4623,8 +4576,7 @@ void I8_gen_DIV_MOD(ENode *expr, short outputReg, short outputRegHi, Operand *ou
if (ENODE_IS(right, EINTCONST))
constval = (((SInt64) right->data.intval.hi) << 32) + right->data.intval.lo;
if (ENODE_IS(right, EINTCONST) && ((shift = I8_log2n(constval)) > 0)) {
-#line 8976
- CError_ASSERT(opleft.optype == OpndType_GPRPair);
+ CError_ASSERT(8976, opleft.optype == OpndType_GPRPair);
if (ENODE_IS(expr, EDIV)) {
I8_ShiftRightImmediate(opleft, shift, is_uns, output->reg, output->regHi, 1);
if (!is_uns) {
@@ -4643,8 +4595,7 @@ void I8_gen_DIV_MOD(ENode *expr, short outputReg, short outputRegHi, Operand *ou
emitpcode(PC_RLWINM, output->regHi, opleft.regHi, 0, 32 - (shift - 32), 31);
emitpcode(PC_MR, output->reg, opleft.reg);
} else {
-#line 9018
- CError_FATAL();
+ CError_FATAL(9018);
}
} else {
short tmpreg1 = ALLOC_GPR();
@@ -4663,8 +4614,7 @@ void I8_gen_DIV_MOD(ENode *expr, short outputReg, short outputRegHi, Operand *ou
GEN_NODE(right, &opright);
coerce_to_register_pair(&opright, right->rtype, 0, 0);
-#line 9048
- CError_ASSERT(opleft.optype == OpndType_GPRPair && opright.optype == OpndType_GPRPair);
+ CError_ASSERT(9048, opleft.optype == OpndType_GPRPair && opright.optype == OpndType_GPRPair);
if (opleft.regHi != high_reg)
emitpcode(PC_MR, high_reg, opleft.regHi);
@@ -4686,8 +4636,7 @@ void I8_gen_DIV_MOD(ENode *expr, short outputReg, short outputRegHi, Operand *ou
else
branch_subroutine(rt_mod2i, 0, used_regs);
} else {
-#line 9074
- CError_FATAL();
+ CError_FATAL(9074);
}
emitpcode(PC_MR, output->reg, low_reg);
@@ -4745,8 +4694,7 @@ void I8_gen_TYPCON(ENode *expr, short outputReg, short outputRegHi, Operand *out
}
if (srctype->size < dsttype->size) {
-#line 9171
- CError_ASSERT(TYPE_IS_8BYTES(dsttype));
+ CError_ASSERT(9171, TYPE_IS_8BYTES(dsttype));
GEN_NODE(inner, output);
if (srctype->size < 4 &&
@@ -4769,8 +4717,7 @@ void I8_gen_TYPCON(ENode *expr, short outputReg, short outputRegHi, Operand *out
if (IS_TYPE_POINTER(srctype)) {
GEN_NODE_TO_REG(inner, outputReg, 0, output);
-#line 9200
- CError_ASSERT(TYPE_IS_8BYTES(expr->rtype));
+ CError_ASSERT(9200, TYPE_IS_8BYTES(expr->rtype));
GEN_NODE_TO_REG(inner, outputReg, 0, output);
regHi = outputRegHi ? outputRegHi : ALLOC_GPR();
@@ -4790,8 +4737,7 @@ void I8_gen_TYPCON(ENode *expr, short outputReg, short outputRegHi, Operand *out
if (IS_TYPE_FLOAT(srctype)) {
if (IS_TYPE_FLOAT(dsttype)) {
-#line 9222
- CError_FATAL();
+ CError_FATAL(9222);
return;
}
@@ -4816,14 +4762,12 @@ void I8_gen_TYPCON(ENode *expr, short outputReg, short outputRegHi, Operand *out
if (TYPE_IS_8BYTES(expr->rtype) && dsttype->size == srctype->size) {
coerce_to_register_pair(output, srctype, outputReg, outputRegHi);
} else {
-#line 9256
- CError_FATAL();
+ CError_FATAL(9256);
}
return;
}
-#line 9261
- CError_FATAL();
+ CError_FATAL(9261);
}
void gen_VECTOR128CONST(ENode *expr, short outputReg, short outputRegHi, Operand *output) {
@@ -4832,10 +4776,8 @@ void gen_VECTOR128CONST(ENode *expr, short outputReg, short outputRegHi, Operand
COVCResult result;
vr = outputReg ? outputReg : ALLOC_VR();
- if (!canoptimizevectorconst(&expr->data.vector128val, expr->rtype, &result)) {
-#line 9282
- CError_FATAL();
- }
+ if (!canoptimizevectorconst(&expr->data.vector128val, expr->rtype, &result))
+ CError_FATAL(9282);
if (result.op1 != -1) {
emitpcode(result.op1, vr, result.arg);
@@ -4853,6 +4795,5 @@ void gen_VECTOR128CONST(ENode *expr, short outputReg, short outputRegHi, Operand
return;
}
-#line 9298
- CError_FATAL();
+ CError_FATAL(9298);
}
diff --git a/compiler_and_linker/unsorted/IrOptimizer.c b/compiler_and_linker/unsorted/IrOptimizer.c
index 462adf3..ae38df0 100644
--- a/compiler_and_linker/unsorted/IrOptimizer.c
+++ b/compiler_and_linker/unsorted/IrOptimizer.c
@@ -1,5 +1,26 @@
#include "compiler/IrOptimizer.h"
+#include "compiler/CError.h"
#include "compiler/CParser.h"
+#include "compiler/InlineAsmPPC.h"
+#include "compiler/IroCSE.h"
+#include "compiler/IroDump.h"
+#include "compiler/IroEval.h"
+#include "compiler/IroFlowgraph.h"
+#include "compiler/IroLinearForm.h"
+#include "compiler/IroSubable.h"
+#include "compiler/IroTransform.h"
+#include "compiler/IROUseDef.h"
+#include "compiler/IroUtil.h"
+#include "compiler/IroVars.h"
+#include "compiler/objects.h"
+#include "compiler/IroPropagate.h"
+#include "compiler/IroPointerAnalysis.h"
+#include "compiler/IroJump.h"
+#include "compiler/IroRangePropagation.h"
+#include "compiler/IroEmptyLoop.h"
+#include "compiler/IroUnrollLoop.h"
+#include "compiler/IroLoop.h"
+#include "compiler/IroExprRegeneration.h"
Boolean DoScalarize;
Boolean DoLinearize;
@@ -9,37 +30,367 @@ Boolean VectorPhaseCalledFromUnroll;
Boolean IRO_Log;
static Boolean stIsSetup;
-static void CountRefToObject() {
+static void CountRefToObject(Object *object, int depth) {
+ static unsigned short LoopUsage[] = {1, 4, 16, 64};
+
+ if (depth > 3)
+ depth = 3;
+
+ object->u.var.info->usage += LoopUsage[depth];
+ object->u.var.info->used = 1;
}
-static void CountARef() {
+static void CountARef(IROLinear *node, int depth) {
+ Object *object;
+
+ object = node->u.node->data.objref;
+ CError_ASSERT(78, object->datatype != DALIAS);
+
+ if (object->datatype == DLOCAL && object->u.var.info) {
+ CountRefToObject(object, depth);
+ if ((node->flags & IROLF_Used) && (node->flags & IROLF_Assigned))
+ CountRefToObject(object, depth);
+
+ if (!(node->flags & IROLF_Immind) && !object->u.var.info->noregister)
+ object->u.var.info->noregister = 2;
+ }
}
-static void CountDoubleInd() {
+static void CountDoubleInd(IROLinear *node, int depth) {
+ if (IRO_IsVariable(node)) {
+ CountARef(node->u.monadic, depth);
+ } else if (node->type == IROLinearOp2Arg) {
+ if (node->nodetype == EADD) {
+ CountDoubleInd(node->u.diadic.left, depth);
+ CountDoubleInd(node->u.diadic.right, depth);
+ } else if (IRO_IsAddressMultiply(node)) {
+ if (IRO_IsVariable(node->u.diadic.left))
+ CountARef(node->u.diadic.left->u.monadic, depth);
+ }
+ }
}
-static void CountUsage() {
+static void CountUsage(void) {
+ IRONode *fnode = IRO_FirstNode;
+ IROLinear *node;
+
+ if (IRO_FirstNode) {
+ for (; fnode; fnode = fnode->nextnode) {
+ for (node = fnode->first; node; node = node->next) {
+ if (IS_LINEAR_ENODE(node, EOBJREF))
+ CountARef(node, fnode->loopdepth);
+ else if (IS_LINEAR_MONADIC(node, EINDIRECT))
+ CountDoubleInd(node->u.monadic, fnode->loopdepth);
+
+ if (node->type == IROLinearAsm) {
+ IAEffects effects;
+ int i;
+
+ CodeGen_GetAsmEffects(node->u.asm_stmt, &effects);
+ for (i = 0; i < effects.numoperands; i++) {
+ Object *object = effects.operands[i].object;
+ if (object->datatype == DLOCAL && object->u.var.info) {
+ CountRefToObject(object, fnode->loopdepth);
+ if (effects.operands[i].type == IAOpnd_3 && !object->u.var.info->noregister)
+ object->u.var.info->noregister = 2;
+ }
+ }
+ }
+
+ if (node == fnode->last)
+ break;
+ }
+ }
+ } else {
+ for (node = IRO_FirstLinear; node; node = node->next) {
+ if (IS_LINEAR_ENODE(node, EOBJREF))
+ CountARef(node, 0);
+ else if (IS_LINEAR_MONADIC(node, EINDIRECT))
+ CountDoubleInd(node->u.monadic, 0);
+ }
+ }
+
+ IRO_CheckForUserBreak();
}
-Statement *IRO_Optimizer(Object *obj, Statement *stmt) {
+Statement *IRO_Optimizer(Object *func, Statement *statements) {
+ Boolean changed;
+ Boolean changed2;
+ int pass;
+ int passCount;
+
+ CError_ASSERT(234, stIsSetup);
+
+ DisableDueToAsm = 0;
+ FunctionName = func;
+ DoScalarize = 1;
+ DoLinearize = 1;
+ EarlyReturn = 0;
+ IRO_Depends = NULL;
+ LoopOptimizerRun = 0;
+ IRO_IsLeafFunction = 1;
+ IRO_FunctionHasReturn = 0;
+
+ IRO_SetupForUserBreakChecking();
+
+ IRO_Dump("Starting function %s\n", func ? func->name->name : "Init-code");
+ IRO_Dump("--------------------------------------------------------------------------------\n");
+
+ if (DoLinearize)
+ IRO_PreLinearize(statements);
+ if (copts.optimizationlevel > 0)
+ IRO_TransformTree(statements);
+
+ VectorPhaseCalledFromUnroll = 0;
+
+ IRO_Linearize(statements);
+
+ CurStat = NULL;
+
+ IRO_FirstExpr = NULL;
+ IRO_LastExpr = NULL;
+ IRO_FirstAssign = NULL;
+ IRO_LastAssign = NULL;
+ IRO_FirstVarUse = NULL;
+ IRO_LastVarUse = NULL;
+ IRO_FirstNode = NULL;
+ IRO_LastNode = NULL;
+
+ if (copts.optimizationlevel > 0)
+ IRO_DoTransformations();
+
+ IRO_BuildFlowgraph(IRO_FirstLinear);
+ IRO_DumpAfterPhase("IRO_BuildflowGraph", 0);
+
+ IRO_FindAllVars();
+ IRO_CheckInit();
+
+ if (!DisableDueToAsm && copts.optimizationlevel > 0 && copts.opt_pointer_analysis && func) {
+ IRO_AnalyzePointers(func);
+ if (copts.opt_propagation && IRO_EvaluateDefinitePointers(func)) {
+ IRO_UpdateFlagsOnInts();
+ IRO_UpdateVars();
+ IRO_DumpAfterPhase("IRO_EvaluateDefinitePointers", 0);
+ }
+ }
+
+ if (copts.optimizationlevel > 0) {
+ changed = IRO_EvaluateConditionals();
+
+ if (!DisableDueToAsm) {
+ changed |= IRO_RemoveUnreachable();
+ IRO_DumpAfterPhase("IRO_RemoveUnreachable", 0);
+ }
+
+ changed |= IRO_RemoveRedundantJumps();
+ IRO_DumpAfterPhase("IRO_RemoveRedundantJumps", 0);
+
+ if (!DisableDueToAsm) {
+ changed |= IRO_RemoveLabels();
+ IRO_DumpAfterPhase("IRO_RemoveLabels()", 0);
+ }
+
+ if (changed) {
+ IRO_BuildFlowgraph(IRO_FirstLinear);
+ IRO_DumpAfterPhase("IRO_BuildflowGraph--1", 0);
+ }
+ }
+
+ if (!DisableDueToAsm && copts.optimizationlevel > 0) {
+ passCount = copts._B4 ? 2 : 1;
+ IRO_CPFirstTime = 1;
+ for (pass = 0; pass < passCount; pass++) {
+ IRO_Dump("*****************\n");
+ IRO_Dump("Dumps for pass=%d\n", pass);
+ IRO_Dump("*****************\n");
+
+ if (DoScalarize)
+ IRO_ScalarizeClassDataMembers();
+ IRO_DumpAfterPhase("IRO_ScalarizeClassDataMembers", 0);
+
+ if (copts.opt_propagation) {
+ IRO_CopyAndConstantPropagation();
+ IRO_CPFirstTime = 0;
+ IRO_ExpressionPropagation();
+ IRO_DumpAfterPhase("Copy and constant propagation", 0);
+
+ IRO_RangePropagateInFNode();
+ IRO_DumpAfterPhase("IRO_RangePropagateInFNode", 0);
+ IRO_UpdateFlagsOnInts();
+ }
+
+ IRO_DumpAfterPhase("IRO_ExpressionPropagation", 0);
+
+ if (copts.opt_dead_assignments || copts.opt_propagation)
+ IRO_UseDef(copts.opt_dead_assignments, copts.opt_propagation);
+ IRO_DumpAfterPhase("after IRO_UseDef", 0);
+
+ IRO_UpdateVars();
+ IRO_ConstantFolding();
+ IRO_DumpAfterPhase("IRO_ConstantFolding", 0);
+
+ IRO_EvaluateConditionals();
+ IRO_RemoveUnreachable();
+ IRO_SimplifyConditionals();
+
+ if (pass == 1 && copts.optimizationlevel > 2) {
+ IRO_RenumberInts();
+ IRO_DumpAfterPhase("Before IRO_FindEmptyLoops", 0);
+ IRO_FindEmptyLoops();
+ IRO_DumpAfterPhase("After IRO_FindEmptyLoops", 0);
+ IRO_RenumberInts();
+ }
+
+ if (copts.opt_unroll_loops && !copts.optimize_for_size && pass == 0) {
+ IRO_DumpAfterPhase("Before IRO_LoopUnroller", 0);
+ IRO_LoopUnroller();
+ IRO_DumpAfterPhase("After IRO_LoopUnroller", 0);
+ IRO_RenumberInts();
+ }
+
+ VectorPhaseCalledFromUnroll = 0;
+
+ if (pass == 0 && (copts.opt_loop_invariants || copts.opt_strength_reduction)) {
+ IRO_DumpAfterPhase("Before IRO_FindLoops", 0);
+ IRO_FindLoops();
+ LoopOptimizerRun = 1;
+ IRO_SetLoopDepth();
+ }
+ IRO_DumpAfterPhase("After IRO_FindLoops", 0);
+
+ if (copts.opt_propagation) {
+ IRO_CopyAndConstantPropagation();
+ IRO_ConstantFolding();
+ IRO_EvaluateConditionals();
+ }
+
+ IRO_DumpAfterPhase("Second pass:IRO_CopyAndConstantPropagation, IRO_ConstantFolding, IRO_EvaluateConditionals", 0);
+
+ if (copts.opt_common_subs)
+ IRO_FindExpressions(NULL, 0);
+
+ if (copts.opt_common_subs) {
+ IRO_ComputeAvail();
+ IRO_CommonSubs();
+ }
+ IRO_DumpAfterPhase("IRO_CommonSubs", 0);
+
+ IRO_UpdateFlagsOnInts();
+ IRO_UpdateVars();
+ IRO_DoTransformations();
+ IRO_ConstantFolding();
+
+ do {
+ IRO_UpdateFlagsOnInts();
+
+ if (copts.opt_dead_code)
+ IRO_RemoveUnreachable();
+ IRO_DumpAfterPhase("IRO_RemoveUnreachable", 0);
+
+ changed2 = IRO_RemoveRedundantJumps();
+ IRO_DumpAfterPhase("IRO_RemoveRedundantJumps", 0);
+
+ changed2 |= IRO_RemoveLabels();
+ IRO_DumpAfterPhase("IRO_RemoveLabels", 0);
+
+ changed2 |= IRO_DoJumpChaining();
+ IRO_DumpAfterPhase("IRO_DoJumpChaining", 0);
+
+ if (copts.opt_propagation) {
+ IRO_RenumberInts();
+ IRO_DumpAfterPhase("Before IRO_CopyAndConstantPropagation", 0);
+ changed2 |= IRO_CopyAndConstantPropagation();
+ IRO_DumpAfterPhase("After IRO_CopyAndConstantPropagation", 0);
+ IRO_ConstantFolding();
+ }
+
+ if (copts.opt_dead_assignments || copts.opt_propagation)
+ changed2 |= IRO_UseDef(copts.opt_dead_assignments, copts.opt_propagation);
+ IRO_DumpAfterPhase("IRO_UseDef", 0);
+
+ changed2 |= IRO_EvaluateConditionals();
+ IRO_DumpAfterPhase("IRO_EvaluateConditionals", 0);
+ } while (changed2);
+ }
+
+ if (copts.opt_lifetimes) {
+ IRO_UseDef(0, 0);
+ IRO_SplitLifetimes();
+ }
+
+ IRO_DoTransformations();
+ IRO_DumpAfterPhase("Before RebuildCondExpressions", 0);
+ }
+
+ IRO_RenumberInts();
+ IRO_DumpAfterPhase("before IRO_RewriteBitFieldTemps", 0);
+ IRO_RewriteBitFieldTemps();
+ IRO_DumpAfterPhase("After IRO_RewriteBitFieldTemps", 0);
+
+ CountUsage();
+
+ if (!DisableDueToAsm) {
+ IRO_RegenerateExpressions();
+ IRO_DumpAfterPhase("IRO_RegenerateExpressions", 0);
+ }
+
+ IRO_DumpAfterPhase("After IRO_Optimizer", 0);
+
+ statements = IRO_Delinearize(IRO_FirstNode, NULL);
+
+ IRO_ZapVarPtrs();
+ freeoheap();
+ return statements;
}
void IRO_Setup(void) {
static Boolean ENodeArraysHaveBeenInitialized;
+
+ if (!stIsSetup) {
+ IRO_Log = 0;
+ IRO_SetupDump();
+ if (!ENodeArraysHaveBeenInitialized) {
+ IRO_InitializeNodeNamesArray();
+ IRO_InitializeIsAssociativeENodeTypeArray();
+ IRO_InitializeIsSubableOpArray();
+ IRO_InitializeAssignmentOpArray();
+ IRO_InitializeComplementaryOpArray();
+ IRO_InitializeComplementaryOpLogicalArray();
+ IRO_InitializeNonAssignmentOpArray();
+ IRO_InitializeAssignmentFoldingFunctionArray();
+ IRO_InitializeIRO_IsModifyOpArray();
+ IRO_InitializeIRO_IsAssignOpArray();
+ ENodeArraysHaveBeenInitialized = 1;
+ }
+ stIsSetup = 1;
+ }
}
void IRO_Cleanup(void) {
+ if (stIsSetup) {
+ IRO_CleanupDump();
+ stIsSetup = 0;
+ }
}
void CodeGen_UpdateOptimizerOptions(void) {
- copts.opt_dead_code = copts.optimizationlevel > 0;
- copts.opt_propagation = copts.optimizationlevel > 1;
- copts.opt_common_subs = copts.optimizationlevel > 1;
- copts.opt_vectorize_loops = copts.optimizationlevel > 2;
- copts.opt_unroll_loops = copts.optimizationlevel > 2;
- copts.opt_dead_assignments = copts.optimizationlevel > 2;
- copts.opt_lifetimes = copts.optimizationlevel > 2;
- copts.opt_strength_reduction = copts.optimizationlevel > 2;
- copts.opt_loop_invariants = copts.optimizationlevel > 2;
- copts._B4 = copts.optimizationlevel > 3;
+ Boolean flag;
+
+ flag = copts.optimizationlevel >= 1;
+ copts.opt_dead_code = flag;
+
+ flag = copts.optimizationlevel >= 2;
+ copts.opt_propagation = flag;
+ copts.opt_common_subs = flag;
+
+ flag = copts.optimizationlevel >= 3;
+ copts.opt_vectorize_loops = flag;
+ copts.opt_unroll_loops = flag;
+ copts.opt_dead_assignments = flag;
+ copts.opt_lifetimes = flag;
+ copts.opt_strength_reduction = flag;
+ copts.opt_loop_invariants = flag;
+
+ flag = copts.optimizationlevel >= 4;
+ copts._B4 = flag;
}
diff --git a/compiler_and_linker/unsorted/IroCSE.c b/compiler_and_linker/unsorted/IroCSE.c
index dd82716..2311786 100644
--- a/compiler_and_linker/unsorted/IroCSE.c
+++ b/compiler_and_linker/unsorted/IroCSE.c
@@ -5,6 +5,7 @@
#include "compiler/IroMalloc.h"
#include "compiler/IroPointerAnalysis.h"
#include "compiler/IroSubable.h"
+#include "compiler/IROUseDef.h"
#include "compiler/IroUtil.h"
#include "compiler/IroVars.h"
#include "compiler/CError.h"
@@ -979,10 +980,22 @@ void IRO_CommonSubs(void) {
IRO_CheckForUserBreak();
}
-static Boolean CountThisSubableOperandUse() {
+static Boolean CountThisSubableOperandUse(IROUse *use) {
+ return use->x1C != 0;
}
-static void GetSubableOperandUseCount() {
+static int GetSubableOperandUseCount(VarRecord *var) {
+ int count = 0;
+ IROUse *use;
+
+ if (var->uses) {
+ for (use = var->uses; use; use = use->varnext) {
+ if (CountThisSubableOperandUse(use))
+ count++;
+ }
+ }
+
+ return count;
}
static void IRO_MakeTopLevelExprForSubableOperand(IROLinear *linear) {
diff --git a/compiler_and_linker/unsorted/IroEval.c b/compiler_and_linker/unsorted/IroEval.c
index e69de29..a34cf89 100644
--- a/compiler_and_linker/unsorted/IroEval.c
+++ b/compiler_and_linker/unsorted/IroEval.c
@@ -0,0 +1,914 @@
+#include "compiler/IroEval.h"
+#include "compiler/CInt64.h"
+#include "compiler/CMachine.h"
+#include "compiler/CParser.h"
+#include "compiler/IroFlowgraph.h"
+#include "compiler/IroLinearForm.h"
+#include "compiler/IroMalloc.h"
+#include "compiler/IroPointerAnalysis.h"
+#include "compiler/IroUtil.h"
+#include "compiler/IroVars.h"
+#include "compiler/enode.h"
+#include "compiler/objects.h"
+#include "compiler/types.h"
+
+static Boolean IsAssociativeENodeType[MAXEXPR];
+
+void IRO_InitializeIsAssociativeENodeTypeArray(void) {
+ int i;
+
+ for (i = 0; i < MAXEXPR; i++)
+ IsAssociativeENodeType[i] = 0;
+
+ IsAssociativeENodeType[EPOSTINC] = 0;
+ IsAssociativeENodeType[EPOSTDEC] = 0;
+ IsAssociativeENodeType[EPREINC] = 0;
+ IsAssociativeENodeType[EPREDEC] = 0;
+ IsAssociativeENodeType[EINDIRECT] = 0;
+ IsAssociativeENodeType[EMONMIN] = 0;
+ IsAssociativeENodeType[EBINNOT] = 0;
+ IsAssociativeENodeType[ELOGNOT] = 0;
+ IsAssociativeENodeType[EFORCELOAD] = 0;
+ IsAssociativeENodeType[EMUL] = 1;
+ IsAssociativeENodeType[EMULV] = 1;
+ IsAssociativeENodeType[EDIV] = 0;
+ IsAssociativeENodeType[EMODULO] = 0;
+ IsAssociativeENodeType[EADDV] = 1;
+ IsAssociativeENodeType[ESUBV] = 0;
+ IsAssociativeENodeType[EADD] = 1;
+ IsAssociativeENodeType[ESUB] = 0;
+ IsAssociativeENodeType[ESHL] = 0;
+ IsAssociativeENodeType[ESHR] = 0;
+ IsAssociativeENodeType[ELESS] = 0;
+ IsAssociativeENodeType[EGREATER] = 0;
+ IsAssociativeENodeType[ELESSEQU] = 0;
+ IsAssociativeENodeType[EGREATEREQU] = 0;
+ IsAssociativeENodeType[EEQU] = 0;
+ IsAssociativeENodeType[ENOTEQU] = 0;
+ IsAssociativeENodeType[EAND] = 1;
+ IsAssociativeENodeType[EXOR] = 1;
+ IsAssociativeENodeType[EOR] = 1;
+ IsAssociativeENodeType[ELAND] = 0;
+ IsAssociativeENodeType[ELOR] = 0;
+ IsAssociativeENodeType[EASS] = 0;
+ IsAssociativeENodeType[EMULASS] = 0;
+ IsAssociativeENodeType[EDIVASS] = 0;
+ IsAssociativeENodeType[EMODASS] = 0;
+ IsAssociativeENodeType[EADDASS] = 0;
+ IsAssociativeENodeType[ESUBASS] = 0;
+ IsAssociativeENodeType[ESHLASS] = 0;
+ IsAssociativeENodeType[ESHRASS] = 0;
+ IsAssociativeENodeType[EANDASS] = 0;
+ IsAssociativeENodeType[EXORASS] = 0;
+ IsAssociativeENodeType[EORASS] = 0;
+ IsAssociativeENodeType[ECOMMA] = 0;
+ IsAssociativeENodeType[EPMODULO] = 0;
+ IsAssociativeENodeType[EROTL] = 0;
+ IsAssociativeENodeType[EROTR] = 0;
+ IsAssociativeENodeType[EBCLR] = 0;
+ IsAssociativeENodeType[EBTST] = 0;
+ IsAssociativeENodeType[EBSET] = 0;
+ IsAssociativeENodeType[ETYPCON] = 0;
+ IsAssociativeENodeType[EBITFIELD] = 0;
+ IsAssociativeENodeType[EINTCONST] = 0;
+ IsAssociativeENodeType[EFLOATCONST] = 0;
+ IsAssociativeENodeType[ESTRINGCONST] = 0;
+ IsAssociativeENodeType[ECOND] = 0;
+ IsAssociativeENodeType[EFUNCCALL] = 0;
+ IsAssociativeENodeType[EFUNCCALLP] = 0;
+ IsAssociativeENodeType[EOBJREF] = 0;
+ IsAssociativeENodeType[EMFPOINTER] = 0;
+ IsAssociativeENodeType[ENULLCHECK] = 0;
+ IsAssociativeENodeType[EPRECOMP] = 0;
+ IsAssociativeENodeType[ETEMP] = 0;
+ IsAssociativeENodeType[EARGOBJ] = 0;
+ IsAssociativeENodeType[ELOCOBJ] = 0;
+ IsAssociativeENodeType[ELABEL] = 0;
+ IsAssociativeENodeType[ESETCONST] = 0;
+ IsAssociativeENodeType[ENEWEXCEPTION] = 0;
+ IsAssociativeENodeType[ENEWEXCEPTIONARRAY] = 0;
+ IsAssociativeENodeType[EOBJLIST] = 0;
+ IsAssociativeENodeType[EMEMBER] = 0;
+ IsAssociativeENodeType[ETEMPLDEP] = 0;
+ IsAssociativeENodeType[EINSTRUCTION] = 0;
+ IsAssociativeENodeType[EDEFINE] = 0;
+ IsAssociativeENodeType[EREUSE] = 0;
+ IsAssociativeENodeType[EASSBLK] = 0;
+ IsAssociativeENodeType[EVECTOR128CONST] = 0;
+ IsAssociativeENodeType[ECONDASS] = 0;
+}
+
+void IRO_TruncateValueToType(CInt64 *val, Type *type) {
+ if (IRO_IsUnsignedType(type)) {
+ switch (type->size) {
+ case 1:
+ CInt64_ConvertUInt8(val);
+ break;
+ case 2:
+ CInt64_ConvertUInt16(val);
+ break;
+ case 4:
+ CInt64_ConvertUInt32(val);
+ break;
+ }
+ } else {
+ switch (type->size) {
+ case 1:
+ CInt64_ConvertInt8(val);
+ break;
+ case 2:
+ CInt64_ConvertInt16(val);
+ break;
+ case 4:
+ CInt64_ConvertInt32(val);
+ break;
+ }
+ }
+}
+
+void IRO_TruncateBitfieldValueToType(CInt64 *val, Type *type, Type *type2) {
+ UInt32 limit;
+ UInt32 i;
+ UInt32 j;
+ CInt64 work;
+
+ work = cint64_zero;
+ limit = TYPE_BITFIELD(type2)->unkB;
+ for (i = 0; i < limit; i++)
+ work = CInt64_Or(work, CInt64_Shl(cint64_one, IRO_MakeULong(i)));
+ *val = CInt64_And(*val, work);
+
+ if (!IRO_IsUnsignedType(type)) {
+ work = cint64_zero;
+ for (j = 0; j <= (i - 1); j++) {
+ if (j == (i - 1))
+ work = CInt64_Or(work, CInt64_Shl(cint64_one, IRO_MakeULong(j)));
+ }
+ if (CInt64_NotEqual(CInt64_And(work, *val), cint64_zero)) {
+ for (j = i - 1; j < 64; j++)
+ *val = CInt64_Or(*val, CInt64_Shl(cint64_one, IRO_MakeULong(j)));
+ }
+ }
+
+ IRO_TruncateValueToType(val, type);
+}
+
+void IRO_ConstantFolding(void) {
+ IROLinear *nd;
+ ENode *expr;
+ int isCompare;
+ int flag;
+ CInt64 val;
+
+ for (nd = IRO_FirstLinear; nd; nd = nd->next) {
+ switch (nd->type) {
+ case IROLinearOp1Arg:
+ if (IRO_IsIntConstant(nd->u.monadic)) {
+ expr = NULL;
+ flag = 0;
+ val = nd->u.monadic->u.node->data.intval;
+ if (nd->nodetype == ETYPCON && IS_TYPE_FLOAT(nd->rtype)) {
+ expr = IRO_NewENode(EFLOATCONST);
+ if (!IRO_IsUnsignedType(nd->u.monadic->rtype))
+ expr->data.floatval.value = CInt64_ConvertToLongDouble(&val);
+ else
+ expr->data.floatval.value = CInt64_ConvertUToLongDouble(&val);
+ expr->rtype = nd->rtype;
+ } else {
+ switch (nd->nodetype) {
+ case ETYPCON:
+ flag = 1;
+ break;
+ case ELOGNOT:
+ val = CInt64_Not(val);
+ flag = 1;
+ break;
+ case EBINNOT:
+ val = CInt64_Inv(val);
+ flag = 1;
+ break;
+ case EMONMIN:
+ val = CInt64_Neg(val);
+ flag = 1;
+ break;
+ }
+
+ if (flag) {
+ IRO_TruncateValueToType(&val, nd->rtype);
+ expr = IRO_NewENode(EINTCONST);
+ expr->rtype = nd->rtype;
+ expr->data.intval = val;
+ }
+ }
+
+ if (expr) {
+ nd->u.monadic->type = IROLinearNop;
+ nd->type = IROLinearOperand;
+ nd->u.node = expr;
+ }
+ }
+ break;
+
+ case IROLinearOp2Arg:
+ if (IRO_IsIntConstant(nd->u.diadic.left) && !IRO_IsIntConstant(nd->u.diadic.right) && IsAssociativeENodeType[nd->nodetype]) {
+ IROLinear *tmp = nd->u.diadic.right;
+ nd->u.diadic.right = nd->u.diadic.left;
+ nd->u.diadic.left = tmp;
+ }
+
+ if (IRO_IsIntConstant(nd->u.diadic.right) && nd->nodetype == ESUB) {
+ nd->nodetype = EADD;
+ if (IRO_IsIntConstant(nd->u.diadic.right)) {
+ CInt64 v;
+ v = CInt64_Neg(nd->u.diadic.right->u.node->data.intval);
+ nd->u.diadic.right->u.node->data.intval = v;
+ } else {
+ Float f;
+ f = CMach_CalcFloatMonadic(
+ nd->u.diadic.right->rtype,
+ '-',
+ nd->u.diadic.right->u.node->data.floatval);
+ nd->u.diadic.right->u.node->data.floatval = f;
+ }
+ }
+
+ if (
+ IRO_IsIntConstant(nd->u.diadic.right) &&
+ IsAssociativeENodeType[nd->nodetype] &&
+ nd->u.diadic.left->type == IROLinearOp2Arg &&
+ nd->u.diadic.left->nodetype == nd->nodetype &&
+ nd->u.diadic.left->rtype == nd->rtype &&
+ IRO_IsIntConstant(nd->u.diadic.left->u.diadic.right) &&
+ nd->u.diadic.left->u.diadic.right->rtype == nd->u.diadic.right->rtype
+ )
+ {
+ IROLinear *tmp = nd->u.diadic.left;
+ nd->u.diadic.left = tmp->u.diadic.left;
+ tmp->u.diadic.left = tmp->u.diadic.right;
+ tmp->u.diadic.right = nd->u.diadic.right;
+ tmp->rtype = tmp->u.diadic.left->rtype;
+ nd->u.diadic.right = tmp;
+ nd = tmp;
+ }
+
+ if (IRO_IsIntConstant(nd->u.diadic.left) && IRO_IsIntConstant(nd->u.diadic.right)) {
+ CInt64 val1 = nd->u.diadic.left->u.node->data.intval;
+ CInt64 val2 = nd->u.diadic.right->u.node->data.intval;
+ flag = 0;
+ switch (nd->nodetype) {
+ case EADD:
+ val = CInt64_Add(val1, val2);
+ flag = 1;
+ break;
+ case ESUB:
+ val = CInt64_Sub(val1, val2);
+ flag = 1;
+ break;
+ case EMUL:
+ if (IRO_IsUnsignedType(nd->rtype))
+ val = CInt64_MulU(val1, val2);
+ else
+ val = CInt64_Mul(val1, val2);
+ flag = 1;
+ break;
+ case EDIV:
+ if (!CInt64_IsZero(&val2)) {
+ if (IRO_IsUnsignedType(nd->rtype))
+ val = CInt64_DivU(val1, val2);
+ else
+ val = CInt64_Div(val1, val2);
+ flag = 1;
+ }
+ break;
+ case EMODULO:
+ if (!CInt64_IsZero(&val2)) {
+ if (IRO_IsUnsignedType(nd->rtype))
+ val = CInt64_ModU(val1, val2);
+ else
+ val = CInt64_Mod(val1, val2);
+ flag = 1;
+ }
+ break;
+ case ESHL:
+ val = CInt64_Shl(val1, val2);
+ flag = 1;
+ break;
+ case ESHR:
+ if (IRO_IsUnsignedType(nd->rtype))
+ val = CInt64_ShrU(val1, val2);
+ else
+ val = CInt64_Shr(val1, val2);
+ flag = 1;
+ break;
+ case EAND:
+ val = CInt64_And(val1, val2);
+ flag = 1;
+ break;
+ case EOR:
+ val = CInt64_Or(val1, val2);
+ flag = 1;
+ break;
+ case EXOR:
+ val = CInt64_Xor(val1, val2);
+ flag = 1;
+ break;
+ case ELESS:
+ if (IRO_IsUnsignedType(nd->u.diadic.left->rtype))
+ CInt64_SetULong(&val, CInt64_LessU(val1, val2));
+ else
+ CInt64_SetULong(&val, CInt64_Less(val1, val2));
+ flag = 1;
+ break;
+ case EGREATER:
+ if (IRO_IsUnsignedType(nd->u.diadic.left->rtype))
+ CInt64_SetULong(&val, CInt64_GreaterU(val1, val2));
+ else
+ CInt64_SetULong(&val, CInt64_Greater(val1, val2));
+ flag = 1;
+ break;
+ case ELESSEQU:
+ if (IRO_IsUnsignedType(nd->u.diadic.left->rtype))
+ CInt64_SetULong(&val, CInt64_LessEqualU(val1, val2));
+ else
+ CInt64_SetULong(&val, CInt64_LessEqual(val1, val2));
+ flag = 1;
+ break;
+ case EGREATEREQU:
+ if (IRO_IsUnsignedType(nd->u.diadic.left->rtype))
+ CInt64_SetULong(&val, CInt64_GreaterEqualU(val1, val2));
+ else
+ CInt64_SetULong(&val, CInt64_GreaterEqual(val1, val2));
+ flag = 1;
+ break;
+ case EEQU:
+ CInt64_SetULong(&val, CInt64_Equal(val1, val2));
+ flag = 1;
+ break;
+ case ENOTEQU:
+ CInt64_SetULong(&val, CInt64_NotEqual(val1, val2));
+ flag = 1;
+ break;
+ }
+
+ if (flag) {
+ IRO_TruncateValueToType(&val, nd->rtype);
+ expr = IRO_NewENode(EINTCONST);
+ expr->rtype = nd->rtype;
+ expr->data.intval = val;
+ nd->u.diadic.left->type = IROLinearNop;
+ nd->u.diadic.right->type = IROLinearNop;
+ nd->type = IROLinearOperand;
+ nd->u.node = expr;
+ }
+ }
+
+ if (IRO_IsFloatConstant(nd->u.diadic.left) && IRO_IsFloatConstant(nd->u.diadic.right)) {
+ Float fval1 = nd->u.diadic.left->u.node->data.floatval;
+ Float fval2 = nd->u.diadic.right->u.node->data.floatval;
+ Float fval;
+ flag = 0;
+ isCompare = 0;
+ switch (nd->nodetype) {
+ case EADD:
+ fval = CMach_CalcFloatDiadic(nd->rtype, fval1, '+', fval2);
+ flag = 1;
+ break;
+ case ESUB:
+ fval = CMach_CalcFloatDiadic(nd->rtype, fval1, '-', fval2);
+ flag = 1;
+ break;
+ case EMUL:
+ fval = CMach_CalcFloatDiadic(nd->rtype, fval1, '*', fval2);
+ flag = 1;
+ break;
+ case EDIV:
+ fval = CMach_CalcFloatDiadic(nd->rtype, fval1, '/', fval2);
+ flag = 1;
+ break;
+ case ELESS:
+ CInt64_SetULong(&val, CMach_CalcFloatDiadicBool(nd->rtype, fval1, '<', fval2));
+ flag = 1;
+ isCompare = 1;
+ break;
+ case EGREATER:
+ CInt64_SetULong(&val, CMach_CalcFloatDiadicBool(nd->rtype, fval1, '>', fval2));
+ flag = 1;
+ isCompare = 1;
+ break;
+ case ELESSEQU:
+ CInt64_SetULong(&val, CMach_CalcFloatDiadicBool(nd->rtype, fval1, TK_LESS_EQUAL, fval2));
+ flag = 1;
+ isCompare = 1;
+ break;
+ case EGREATEREQU:
+ CInt64_SetULong(&val, CMach_CalcFloatDiadicBool(nd->rtype, fval1, TK_GREATER_EQUAL, fval2));
+ flag = 1;
+ isCompare = 1;
+ break;
+ case EEQU:
+ CInt64_SetULong(&val, CMach_CalcFloatDiadicBool(nd->rtype, fval1, TK_LOGICAL_EQ, fval2));
+ flag = 1;
+ isCompare = 1;
+ break;
+ case ENOTEQU:
+ CInt64_SetULong(&val, CMach_CalcFloatDiadicBool(nd->rtype, fval1, TK_LOGICAL_NE, fval2));
+ flag = 1;
+ isCompare = 1;
+ break;
+ }
+
+ if (flag) {
+ if (isCompare) {
+ IRO_TruncateValueToType(&val, nd->rtype);
+ expr = IRO_NewENode(EINTCONST);
+ expr->rtype = nd->rtype;
+ expr->data.intval = val;
+ nd->u.diadic.left->type = IROLinearNop;
+ nd->u.diadic.right->type = IROLinearNop;
+ nd->type = IROLinearOperand;
+ nd->u.node = expr;
+ } else {
+ expr = IRO_NewENode(EFLOATCONST);
+ expr->rtype = nd->rtype;
+ expr->data.floatval = fval;
+ nd->u.diadic.left->type = IROLinearNop;
+ nd->u.diadic.right->type = IROLinearNop;
+ nd->type = IROLinearOperand;
+ nd->u.node = expr;
+ }
+ }
+ }
+
+ break;
+ }
+ }
+
+ IRO_CheckForUserBreak();
+}
+
+Boolean IRO_EvaluateConditionals(void) {
+ IRONode *fnode;
+ IROLinear *nd;
+ Boolean changed = 0;
+ SwitchInfo *switchInfo;
+ SwitchCase *swcase;
+ char found;
+ CInt64 val;
+
+ for (fnode = IRO_FirstNode; fnode; fnode = fnode->nextnode) {
+ nd = fnode->last;
+ switch (nd->type) {
+ case IROLinearIf:
+ case IROLinearIfNot:
+ if (IRO_IsIntConstant(nd->u.label.x4)) {
+ Boolean isZero = CInt64_IsZero(&nd->u.label.x4->u.node->data.intval);
+ IRO_NopOut(nd->u.label.x4);
+ if ((isZero == 0) == (nd->type == IROLinearIf))
+ nd->type = IROLinearGoto;
+ else
+ nd->type = IROLinearNop;
+ changed = 1;
+ }
+ break;
+
+ case IROLinearSwitch:
+ if (IRO_IsIntConstant(nd->u.swtch.x4)) {
+ val = nd->u.swtch.x4->u.node->data.intval;
+ switchInfo = nd->u.swtch.info;
+ swcase = switchInfo->cases;
+
+ IRO_NopOut(nd->u.swtch.x4);
+ nd->type = IROLinearGoto;
+
+ found = 0;
+ while (swcase) {
+ if (CInt64_GreaterEqual(val, swcase->min) && CInt64_LessEqual(val, swcase->max)) {
+ found = 1;
+ nd->u.label.label = swcase->label;
+ break;
+ }
+ swcase = swcase->next;
+ }
+
+ if (!found)
+ nd->u.label.label = switchInfo->defaultlabel;
+ changed = 1;
+ }
+ break;
+ }
+ }
+
+ if (changed) {
+ IRO_ComputeSuccPred();
+ IRO_ComputeDom();
+ }
+ IRO_CheckForUserBreak();
+
+ return changed;
+}
+
+static int EEquConst(IROLinear *nd) {
+ return nd && (nd->nodetype == EEQU) && IRO_IsIntConstant(nd->u.diadic.right);
+}
+
+static Object *VEquConst(IROLinear *nd) {
+ if (EEquConst(nd))
+ return IRO_IsVariable(nd->u.diadic.left);
+ else
+ return NULL;
+}
+
+static int IsConsecutive(CInt64 a, CInt64 b) {
+ CInt64 diff;
+
+ if (!CInt64_Equal(a, cint64_min) && !CInt64_Equal(b, cint64_min)) {
+ diff = CInt64_Sub(b, a);
+ return CInt64_Equal(diff, cint64_one) || CInt64_Equal(diff, cint64_negone);
+ }
+
+ return 0;
+}
+
+static IROLinear *findLabel(CLabel *label) {
+ IROLinear *nd;
+
+ for (nd = IRO_FirstLinear; nd; nd = nd->next) {
+ if (nd->type == IROLinearLabel && nd->u.label.label == label)
+ break;
+ }
+
+ return nd;
+}
+
+static IROLinear *leftLeaveOf(IROLinear *nd) {
+ switch (nd->type) {
+ case IROLinearOp1Arg:
+ return leftLeaveOf(nd->u.monadic);
+ case IROLinearOp2Arg:
+ return leftLeaveOf(nd->u.diadic.left);
+ case IROLinearOperand:
+ return nd;
+ default:
+ return NULL;
+ }
+}
+
+static int checkNode(IRONode *fnode) {
+ IROLinear *nd;
+
+ if (fnode->numpred <= 1) {
+ nd = fnode->first;
+ while (nd != fnode->last && (nd->type == IROLinearNop || nd->type == IROLinearLabel))
+ nd = nd->next;
+
+ if (nd == leftLeaveOf(fnode->last->u.label.x4))
+ return 1;
+ }
+
+ return 0;
+}
+
+static int checkLabel(CLabel *label, IRONode *fnode) {
+ switch (fnode->last->type) {
+ case IROLinearIf:
+ if (label == fnode->last->u.label.label)
+ return 1;
+ break;
+ }
+
+ return 0;
+}
+
+static Object *checkExpr(Object *a, IROLinear *nd) {
+ Object *b = VEquConst(nd);
+
+ if ((!a || a == b) && !IRO_HasSideEffect(nd))
+ return b;
+
+ return NULL;
+}
+
+static int checkStruct(IRONode *fnode1, IRONode *fnode2) {
+ CLabel *label;
+ Object *var;
+
+ if (fnode1 == fnode2)
+ return (int) checkExpr(NULL, fnode1->last->u.label.x4);
+
+ label = fnode1->last->u.label.label;
+ var = IRO_IsVariable(fnode1->last->u.label.x4->u.monadic);
+ return checkNode(fnode2) && checkLabel(label, fnode2) && checkExpr(var, fnode2->last->u.label.x4);
+}
+
+typedef struct ReduceInfo {
+ int x0;
+ int x4;
+ Object *x8;
+ IRONode *fnode;
+ struct ReduceInfo *next;
+ CInt64 val;
+} ReduceInfo;
+
+static int MarkPattern1(ReduceInfo *info1, ReduceInfo *info2, CInt64 *val) {
+ ReduceInfo *scan;
+
+ if (!info2)
+ return 0;
+
+ if (info2->x0)
+ return MarkPattern1(info1, info2->next, val);
+
+ for (scan = info1; scan; scan = scan->next) {
+ if (scan->x0 == 2) {
+ if (CInt64_Equal(info2->val, scan->val)) {
+ IRO_NopOut(scan->fnode->last);
+ IRO_NopOut(scan->fnode->last->u.label.x4); // right union?
+ scan->x0 = -1;
+ return MarkPattern1(info1, info2->next, val);
+ }
+
+ if (IsConsecutive(info2->val, scan->val)) {
+ info2->x0 = 2;
+ if (CInt64_Greater(*val, scan->val))
+ *val = scan->val;
+ if (CInt64_Greater(*val, info2->val))
+ *val = info2->val;
+ MarkPattern1(scan->next, info2, val);
+ MarkPattern1(info1, info1->next, val);
+ return 1;
+ }
+ }
+ }
+
+ return MarkPattern1(info1, info2->next, val);
+}
+
+static int DoReducible1(ReduceInfo *info, CInt64 val) {
+ ReduceInfo *last;
+ ReduceInfo *scan;
+ IROLinear *right;
+ IROLinear *left;
+ IROLinear *typconRight;
+ IROLinear *typconLeft;
+ IROLinear *cond;
+ int count;
+
+ count = 0;
+ for (scan = info; scan; scan = scan->next) {
+ if (scan->x0 == 2) {
+ last = scan;
+ count++;
+ }
+ }
+
+ if (!count)
+ return 0;
+
+ for (scan = info; scan != last; scan = scan->next) {
+ if (scan->x0 == 2) {
+ scan->x0 = -1;
+ IRO_NopOut(scan->fnode->last);
+ IRO_NopOut(scan->fnode->last->u.label.x4);
+ }
+ }
+
+ last->x0 = -1;
+
+ cond = last->fnode->last;
+ cond->u.label.x4->nodetype = ELESSEQU;
+ CInt64_SetULong(&cond->u.label.x4->u.diadic.right->u.node->data.intval, count - 1);
+
+ typconLeft = IRO_NewLinear(IROLinearOp1Arg);
+ typconLeft->nodetype = ETYPCON;
+ typconLeft->rtype = IRO_UnsignedType(cond->u.label.x4->u.diadic.left->rtype);
+ typconLeft->index = ++IRO_NumLinear;
+
+ typconRight = IRO_NewLinear(IROLinearOp1Arg);
+ *typconRight = *typconLeft;
+ typconRight->index = ++IRO_NumLinear;
+
+ left = IRO_NewLinear(IROLinearOp2Arg);
+ left->nodetype = EADD;
+ left->rtype = cond->u.label.x4->u.diadic.left->rtype;
+ left->index = ++IRO_NumLinear;
+
+ right = IRO_NewLinear(IROLinearOperand);
+ right->nodetype = EINTCONST;
+ right->rtype = cond->u.label.x4->u.diadic.left->rtype;
+ right->index = ++IRO_NumLinear;
+ right->u.node = IRO_NewENode(EINTCONST);
+ right->u.node->data.intval = CInt64_Neg(val);
+ right->u.node->rtype = right->rtype;
+
+ typconLeft->next = cond->u.label.x4->u.diadic.left->next;
+ cond->u.label.x4->u.diadic.left->next = right;
+ right->next = left;
+ left->next = typconLeft;
+
+ typconRight->next = cond->u.label.x4->u.diadic.right->next;
+ cond->u.label.x4->u.diadic.right->next = typconRight;
+
+ typconLeft->u.monadic = left;
+ left->u.diadic.left = cond->u.label.x4->u.diadic.left;
+ left->u.diadic.right = right;
+ cond->u.label.x4->u.diadic.left = typconLeft;
+ typconRight->u.monadic = cond->u.label.x4->u.diadic.right;
+ cond->u.label.x4->u.diadic.right = typconRight;
+
+ return count;
+};
+
+static int ReducePattern1(IRONode *startnode, IRONode *endnode) {
+ ReduceInfo *infos;
+ ReduceInfo *info;
+ int changed = 0;
+ int count;
+ IRONode *fnode;
+ int i;
+ int j;
+ CInt64 val;
+
+ if (startnode == endnode)
+ return 0;
+
+ count = 0;
+ for (fnode = startnode; fnode != endnode; fnode = fnode->nextnode)
+ count++;
+
+ infos = oalloc(sizeof(ReduceInfo) * ++count);
+
+ fnode = startnode;
+ for (i = 0; i < count; i++) {
+ infos[i].x0 = 0;
+ infos[i].x4 = 0;
+ infos[i].fnode = fnode;
+ infos[i].next = NULL;
+ infos[i].x8 = VEquConst(fnode->last->u.label.x4);
+ if (infos[i].x8) {
+ infos[i].val = fnode->last->u.label.x4->u.diadic.right->u.node->data.intval;
+ infos[i].x4 = 1;
+ }
+ fnode = fnode->nextnode;
+ }
+
+ for (j = 0; j < count; j++) {
+ if (infos[j].x4 == 1 && infos[j].x8) {
+ infos[j].x4 = -1;
+ info = &infos[j];
+ for (i = j + 1; i < count; i++) {
+ if (infos[j].x8 == infos[i].x8) {
+ info->next = &infos[i];
+ info = &infos[i];
+ infos[i].x4 = 0;
+ }
+ }
+ }
+ }
+
+ for (j = 0; j < count; j++) {
+ if (infos[j].x4 == -1) {
+ for (info = &infos[j]; info; info = info->next) {
+ if (info->x0 == 0) {
+ info->x0 = 2;
+ val = info->val;
+ if (MarkPattern1(&infos[j], info->next, &val)) {
+ changed = 1;
+ DoReducible1(&infos[j], val);
+ } else {
+ info->x0 = -1;
+ }
+ }
+ }
+ }
+ }
+
+ return changed;
+}
+
+static int ReduceConsecutiveIf(IRONode *startnode, IRONode *endnode) {
+ IRONode *node31;
+ IRONode *node30;
+ int changed = 0;
+
+ while (startnode != endnode) {
+ if (checkStruct(startnode, startnode))
+ break;
+ startnode = startnode->nextnode;
+ }
+
+ node31 = startnode;
+ if (startnode != endnode) {
+ node30 = startnode;
+ node31 = startnode->nextnode;
+ while (node31 != endnode) {
+ if (checkStruct(startnode, node31)) {
+ node30 = node31;
+ node31 = node31->nextnode;
+ } else {
+ node31 = node30;
+ break;
+ }
+ }
+
+ if (node31 == endnode && !checkStruct(startnode, node31))
+ node31 = node30;
+
+ if (startnode != node31 && ReducePattern1(startnode, node31))
+ changed = 1;
+
+ if (node31 != endnode)
+ node31 = node31->nextnode;
+ }
+
+ if (node31 != endnode && ReduceConsecutiveIf(node31, endnode))
+ changed = 1;
+
+ return changed;
+}
+
+int IRO_SimplifyConditionals(void) {
+ IRONode *fnode;
+ IRONode *start;
+ IRONode *end;
+ int changed = 0;
+
+ for (fnode = IRO_FirstNode; fnode; fnode = fnode->nextnode) {
+ if (fnode->last->type == IROLinearIf) {
+ start = end = fnode;
+ while (fnode->nextnode && fnode->nextnode->last->type == IROLinearIf) {
+ end = fnode = fnode->nextnode;
+ }
+ if (start != end && ReduceConsecutiveIf(start, end))
+ changed = 1;
+ }
+ }
+
+ if (changed) {
+ IRO_ComputeSuccPred();
+ IRO_ComputeDom();
+ }
+ IRO_CheckForUserBreak();
+ return changed;
+}
+
+Boolean IRO_EvaluateDefinitePointers(Object *func) {
+ IROLinear *nd;
+ Boolean result; // r29
+ Boolean changed; // r28
+ Boolean changed2; // r26
+ IROLinear *nd2; // r25
+ IROListNode *scan; // r25
+ IROListNode *list;
+
+ if (!copts.opt_pointer_analysis)
+ return 0;
+
+ result = 0;
+
+ do {
+ changed = 0;
+
+ for (nd = IRO_FirstLinear; nd; nd = nd->next) {
+ if (
+ nd->type == IROLinearOp1Arg &&
+ nd->nodetype == EINDIRECT &&
+ !(nd->flags & IROLF_Assigned) &&
+ nd->pointsToFunction &&
+ !IRO_HasSideEffect(nd) &&
+ PointerAnalysis_IsLinearNodePointerExprDefinite(func, nd)
+ )
+ {
+ list = NULL;
+ PointerAnalysis_LookupLinearNodePointerExpr(func, nd, &list);
+ if (list) {
+ if (list->list.head && list->list.tail && !list->nextList) {
+ changed2 = IRO_LocateFather_Cut_And_Paste(nd, list->list.tail) != NULL;
+ if (changed2) {
+ IRO_PasteAfter(list->list.head, list->list.tail, nd);
+ for (nd2 = list->list.head; nd2 != list->list.tail->next; nd2 = nd2->next) {
+ if (nd2->type == IROLinearOperand && nd2->u.node->type == EOBJREF) {
+ if (nd2->u.node->data.objref->datatype == DDATA || nd2->u.node->data.objref->datatype == DLOCAL)
+ IRO_FindVar(nd2->u.node->data.objref, 1, 1);
+ else
+ nd2->u.node->data.objref->varptr = NULL;
+ }
+ }
+ }
+ changed |= changed2;
+ }
+
+ while (list) {
+ scan = list->nextList;
+ IRO_free(list);
+ list = scan;
+ }
+ }
+ }
+ }
+
+ result |= changed;
+ IRO_CheckForUserBreak();
+ } while (changed);
+
+ return result;
+}
diff --git a/compiler_and_linker/unsorted/IroFlowgraph.c b/compiler_and_linker/unsorted/IroFlowgraph.c
index f9a18fd..5c9c840 100644
--- a/compiler_and_linker/unsorted/IroFlowgraph.c
+++ b/compiler_and_linker/unsorted/IroFlowgraph.c
@@ -331,5 +331,109 @@ IRONode *IRO_NewFlowGraphNode(void) {
}
IRONode *IRO_MergeFlowGraphNodes(IRONode *a, IRONode *b) {
- // TODO
+ IRONode *succ;
+ Boolean found;
+ UInt32 i;
+ UInt32 j;
+ UInt32 k;
+
+ if (a->nextnode == b && a->last && b->first && a->last->next == b->first) {
+ if (b->first->type == IROLinearLabel)
+ IRO_NopOut(b->first);
+
+ a->nextnode = b->nextnode;
+ a->last = b->last;
+
+ for (i = 0; i < a->numsucc; i++) {
+ if (b->index == a->succ[i]) {
+ for (j = i; j < a->numsucc; j++) {
+ if ((j + 1) < a->numsucc)
+ a->succ[j] = a->succ[j + 1];
+ else
+ a->succ[j] = 0;
+ }
+ a->numsucc--;
+ break;
+ }
+ }
+
+ for (i = 0; i < b->numsucc; i++) {
+ succ = IRO_NodeTable[b->succ[i]];
+ for (j = 0; j < a->numsucc; j++) {
+ if (b->succ[i] == a->succ[j])
+ break;
+ }
+
+ if (j == a->numsucc) {
+ AddSucc(a, IRO_NodeTable[b->succ[i]]);
+ succ->numpred--;
+ }
+
+ found = 0;
+ for (j = 0; j < succ->numpred; j++) {
+ if (a->index == succ->pred[j]) {
+ found = 1;
+ break;
+ }
+ }
+
+ for (j = 0; j < succ->numpred; j++) {
+ if (b->index == succ->pred[j]) {
+ if (!found) {
+ succ->pred[j] = a->index;
+ } else {
+ for (k = j; k < succ->numpred; k++) {
+ if ((k + 1) < succ->numpred)
+ succ->pred[k] = succ->pred[k + 1];
+ else
+ succ->pred[k] = 0;
+ }
+ succ->numpred--;
+ }
+ break;
+ }
+ }
+ }
+
+ b->numsucc = b->numpred = 0;
+ b->first = b->last = NULL;
+ b->nextnode = NULL;
+ b->x36 = 0;
+ b->x37 = 0;
+ b->mustreach = 0;
+ b->x39 = 0;
+ b->loopdepth = 0;
+
+ if (IRO_LastNode == b)
+ IRO_LastNode = a;
+
+ if (IRO_FirstExpr && IRO_LastExpr) {
+ IROExpr *expr;
+ for (expr = IRO_FirstExpr; expr && expr != IRO_LastExpr->next; expr = expr->next) {
+ if (expr->node == b)
+ expr->node = a;
+ }
+ }
+
+ if (IRO_FirstAssign && IRO_LastAssign) {
+ IROAssign *assign;
+ for (assign = IRO_FirstAssign; assign && assign != IRO_LastAssign->next; assign = assign->next) {
+ if (assign->node == b)
+ assign->node = a;
+ }
+ }
+
+ if (IRO_FirstVarUse && IRO_LastVarUse) {
+ IROUse *use;
+ for (use = IRO_FirstVarUse; use && use != IRO_LastVarUse->globalnext; use = use->globalnext) {
+ if (use->node == b)
+ use->node = a;
+ }
+ }
+
+ IRO_NodeTable[b->index] = NULL;
+ return a;
+ }
+
+ return NULL;
}
diff --git a/compiler_and_linker/unsorted/IroLoop.c b/compiler_and_linker/unsorted/IroLoop.c
index 01391bd..8a7f4fe 100644
--- a/compiler_and_linker/unsorted/IroLoop.c
+++ b/compiler_and_linker/unsorted/IroLoop.c
@@ -1902,7 +1902,7 @@ IROLoop *ExtractLoopInfo(IRONode *fnode) {
if (IS_LINEAR_DIADIC_2(loop->nd18, ELESS, ELESSEQU)) {
if (nd21->nodetype == EADDASS) {
if (scanind->addConst == 1)
- loop->flags |= LoopFlags_100;
+ loop->flags |= LP_LOOP_STEP_ISADD;
if (scanind->addConst > 0)
loop->flags |= LP_LOOP_STEP_ISPOS;
} else if (nd21->nodetype == EASS &&
@@ -1910,7 +1910,7 @@ IROLoop *ExtractLoopInfo(IRONode *fnode) {
IRO_IsIntConstant(tmp18 = nd21->u.diadic.right->u.diadic.right) &&
CTool_EndianReadWord32(&tmp18->u.node->data.intval.hi) == 0) {
if (CInt64_GetULong(&tmp18->u.node->data.intval) == 1)
- loop->flags |= LoopFlags_100;
+ loop->flags |= LP_LOOP_STEP_ISADD;
if (CInt64_GetULong(&tmp18->u.node->data.intval) > 0)
loop->flags |= LP_LOOP_STEP_ISPOS;
}
@@ -1918,7 +1918,7 @@ IROLoop *ExtractLoopInfo(IRONode *fnode) {
} else if (nd21->type == IROLinearOp1Arg) {
if (nd21->nodetype == EPREINC || nd21->nodetype == EPOSTINC) {
if (scanind->addConst == 1)
- loop->flags |= LoopFlags_100;
+ loop->flags |= LP_LOOP_STEP_ISADD;
if (scanind->addConst > 0)
loop->flags |= LP_LOOP_STEP_ISPOS;
}
@@ -1997,7 +1997,7 @@ IROLoop *ExtractLoopInfo(IRONode *fnode) {
for (scanind = FirstInd; scanind; scanind = scanind->next) {
if (scanind->var->object == obj) {
IRO_Dump("Induction has DIV: %s\n", obj->name->name);
- scanind->flags |= LoopInd_2;
+ scanind->flags |= LoopInd_HasDiv;
}
}
}
@@ -2008,7 +2008,7 @@ IROLoop *ExtractLoopInfo(IRONode *fnode) {
for (scanind = FirstInd; scanind && obj; scanind = scanind->next) {
if (scanind->var->object == obj) {
IRO_Dump("Induction has MOD: %s\n", obj->name->name);
- scanind->flags |= LoopInd_1;
+ scanind->flags |= LoopInd_HasMod;
}
}
}
diff --git a/compiler_and_linker/unsorted/IroPointerAnalysis.c b/compiler_and_linker/unsorted/IroPointerAnalysis.c
index a47d544..0fb2498 100644
--- a/compiler_and_linker/unsorted/IroPointerAnalysis.c
+++ b/compiler_and_linker/unsorted/IroPointerAnalysis.c
@@ -43,9 +43,8 @@ static Boolean LocationIsVolatile(LocationSet *loc, Object *proc) {
Boolean result;
Type *rtype;
-#line 932
- IRO_ASSERT(loc != NULL);
- IRO_ASSERT(proc != NULL);
+ IRO_ASSERT(932, loc != NULL);
+ IRO_ASSERT(933, proc != NULL);
result = 0;
@@ -107,9 +106,8 @@ static Object *GetLocalObject(PALocalVar *local, Object *proc, Boolean flag) {
Object *obj;
char *name;
-#line 999
- IRO_ASSERT(local != NULL);
- IRO_ASSERT(proc != NULL);
+ IRO_ASSERT(999, local != NULL);
+ IRO_ASSERT(1000, proc != NULL);
obj = PALocalVar_Get0_sub_4847E0(local);
name = PALocalVar_Get4_sub_4847D0(local);
@@ -131,8 +129,7 @@ static Object *GetLocalObject(PALocalVar *local, Object *proc, Boolean flag) {
}
static Boolean ObjectIsAnExtendedParamCandidate(Object *obj) {
-#line 1042
- IRO_ASSERT(obj != NULL);
+ IRO_ASSERT(1042, obj != NULL);
return Inline_IsObjectData(obj) ||
obj->datatype == DABSOLUTE ||
@@ -142,8 +139,7 @@ static Boolean ObjectIsAnExtendedParamCandidate(Object *obj) {
}
static Boolean ObjectIsAFunction(Object *obj) {
-#line 1054
- IRO_ASSERT(obj != NULL);
+ IRO_ASSERT(1054, obj != NULL);
return obj->datatype == DFUNC ||
obj->datatype == DVFUNC ||
@@ -157,18 +153,16 @@ static Boolean LocationSetRepresentsSingleLocation(LocationSet *ls, Object *proc
ExtendedParam *ep;
ObjectSet *objSet;
-#line 1073
- IRO_ASSERT(ls != NULL);
- IRO_ASSERT(proc == NULL || proc != NULL);
- IRO_ASSERT(pointsToFunc == NULL || pointsToFunc != NULL);
+ IRO_ASSERT(1073, ls != NULL);
+ IRO_ASSERT(1074, proc == NULL || proc != NULL);
+ IRO_ASSERT(1075, pointsToFunc == NULL || pointsToFunc != NULL);
result = 1;
if (LocationSet_IsUnknown(ls) || LocationSet_stride(ls)) {
result = 0;
} else {
mb = LocationSet_block(ls);
-#line 1084
- IRO_ASSERT(mb != NULL);
+ IRO_ASSERT(1084, mb != NULL);
kind = PAMemoryBlock_kind(mb);
if (kind == PAMEMORYBLOCKKIND_HEAPBLOCK) {
@@ -217,10 +211,9 @@ static void EvalExprAction(LocationSet *ls, void *refcon) {
UInt32 stride;
PAMemoryBlock *mb;
-#line 1151
- IRO_ASSERT(ls != NULL);
- IRO_ASSERT(!LocationSet_IsUnknown(ls));
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(1151, ls != NULL);
+ IRO_ASSERT(1152, !LocationSet_IsUnknown(ls));
+ IRO_ASSERT(1153, refcon != NULL);
value = *((CInt64 *) refcon);
stride = LocationSet_stride(ls);
@@ -247,10 +240,9 @@ static void EvalExprAction(LocationSet *ls, void *refcon) {
static void EvalExprAction2(LocationSet *ls, void *refcon) {
UInt32 value;
-#line 1188
- IRO_ASSERT(ls != NULL);
- IRO_ASSERT(!LocationSet_IsUnknown(ls));
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(1188, ls != NULL);
+ IRO_ASSERT(1189, !LocationSet_IsUnknown(ls));
+ IRO_ASSERT(1190, refcon != NULL);
value = CInt64_GetULong((CInt64 *) refcon);
if (value) {
@@ -279,9 +271,8 @@ typedef struct EvalExprAction3Params {
static void EvalExprAction3(LocationSet *ls, void *refcon) {
EvalExprAction3Params *params;
-#line 1219
- IRO_ASSERT(ls != NULL);
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(1219, ls != NULL);
+ IRO_ASSERT(1220, refcon != NULL);
params = refcon;
@@ -302,9 +293,8 @@ static void EvalExprAction4(LocationSet *ls, void *refcon) {
Type *type;
PAMemoryBlock *mb;
-#line 1235
- IRO_ASSERT(ls != NULL);
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(1235, ls != NULL);
+ IRO_ASSERT(1236, refcon != NULL);
type = refcon;
@@ -340,12 +330,11 @@ static Boolean EvalExpr(LocationSetSet *set, Object *proc, IROLinear *Int, Stack
EvalExprAction3Params params;
IROLinear *originalInt;
-#line 1284
- IRO_ASSERT(set == NULL || set != NULL);
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(Int != NULL);
- IRO_ASSERT(map == NULL || map != NULL);
- IRO_ASSERT(stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
+ IRO_ASSERT(1284, set == NULL || set != NULL);
+ IRO_ASSERT(1285, proc != NULL);
+ IRO_ASSERT(1286, Int != NULL);
+ IRO_ASSERT(1287, map == NULL || map != NULL);
+ IRO_ASSERT(1288, stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
result = 0;
lss = LocationSetSet_New();
@@ -355,16 +344,14 @@ static Boolean EvalExpr(LocationSetSet *set, Object *proc, IROLinear *Int, Stack
while (Int && Int->type == IROLinearOp1Arg && Int->nodetype == ETYPCON)
Int = Int->u.monadic;
-#line 1302
- IRO_ASSERT(Int != NULL);
+ IRO_ASSERT(1302, Int != NULL);
if (IRO_IsAssignment(Int)) {
if (Int->type == IROLinearOp1Arg)
indirect = Int->u.monadic;
else
indirect = Int->u.diadic.left;
-#line 1310
- IRO_ASSERT(indirect->type == IROLinearOp1Arg && indirect->nodetype == EINDIRECT);
+ IRO_ASSERT(1310, indirect->type == IROLinearOp1Arg && indirect->nodetype == EINDIRECT);
lss2 = LocationSetSet_New();
LocationSetSet_Init(lss2);
@@ -387,8 +374,7 @@ static Boolean EvalExpr(LocationSetSet *set, Object *proc, IROLinear *Int, Stack
LocationSetSet_Term(lss2);
LocationSetSet_Delete(lss2);
} else if (Int->type == IROLinearFunccall) {
-#line 1338
- IRO_ASSERT(Int->u.funccall.returnedLocs != NULL);
+ IRO_ASSERT(1338, Int->u.funccall.returnedLocs != NULL);
LocationSetSet_AddSet(lss, Int->u.funccall.returnedLocs);
} else if (Int->type == IROLinearOp1Arg && Int->nodetype == EINDIRECT) {
lss2 = LocationSetSet_New();
@@ -425,12 +411,10 @@ static Boolean EvalExpr(LocationSetSet *set, Object *proc, IROLinear *Int, Stack
flag2 = 0;
if (addr->numObjRefs == 1) {
Object *obj;
-#line 1383
- IRO_ASSERT(addr->objRefs->element->type == IROLinearOperand);
- IRO_ASSERT(addr->objRefs->element->u.node->type == EOBJREF);
+ IRO_ASSERT(1383, addr->objRefs->element->type == IROLinearOperand);
+ IRO_ASSERT(1384, addr->objRefs->element->u.node->type == EOBJREF);
obj = ((IROLinear *) addr->objRefs->element)->u.node->data.objref;
-#line 1387
- IRO_ASSERT(obj != NULL);
+ IRO_ASSERT(1387, obj != NULL);
result |= EvalExpr(lss, proc, addr->objRefs->element, stackPtr, map, ptf);
flag2 = 1;
}
@@ -536,8 +520,7 @@ static Boolean EvalExpr(LocationSetSet *set, Object *proc, IROLinear *Int, Stack
addend = list->element;
if (addend) {
-#line 1536
- IRO_ASSERT(IRO_IsIntConstant(addend));
+ IRO_ASSERT(1536, IRO_IsIntConstant(addend));
value = CInt64_Add(value, addend->u.node->data.intval);
}
@@ -584,8 +567,7 @@ static Boolean EvalExpr(LocationSetSet *set, Object *proc, IROLinear *Int, Stack
thing = Int->u.node;
} else if (Int->u.node->type == EOBJREF) {
obj = Int->u.node->data.objref;
-#line 1597
- IRO_ASSERT(obj != NULL);
+ IRO_ASSERT(1597, obj != NULL);
if (ObjectIsAnExtendedParamCandidate(obj)) {
kind = PAMEMORYBLOCKKIND_EXTENDEDPARAM;
thing = CreateExtendedParam(stackPtr, map, obj, &result);
@@ -619,12 +601,10 @@ static Boolean EvalExpr(LocationSetSet *set, Object *proc, IROLinear *Int, Stack
LocationSetSet_Init(lss2);
result |= EvalExpr(lss2, proc, Int->u.monadic, stackPtr, map, ptf);
- if (LocationSetSet_Count(lss2) == 1 && (ls = LocationSetSet_FindFirst(lss2))) {
+ if (LocationSetSet_Count(lss2) == 1 && (ls = LocationSetSet_FindFirst(lss2)))
LocationSetSet_AddUnknown(lss, NULL, NULL, ls);
- } else {
-#line 1643
- CError_FATAL();
- }
+ else
+ CError_FATAL(1643);
LocationSetSet_Term(lss2);
LocationSetSet_Delete(lss2);
@@ -706,11 +686,11 @@ static Boolean EvalENodeExpr(LocationSetSet *set, Object *proc, ENode *Int, Stac
EvalExprAction3Params params;
ENode *originalInt;
- IRO_ASSERT(set == NULL || set != NULL);
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(Int != NULL);
- IRO_ASSERT(map == NULL || map != NULL);
- IRO_ASSERT(stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
+ IRO_ASSERT(0, set == NULL || set != NULL);
+ IRO_ASSERT(0, proc != NULL);
+ IRO_ASSERT(0, Int != NULL);
+ IRO_ASSERT(0, map == NULL || map != NULL);
+ IRO_ASSERT(0, stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
result = 0;
lss = LocationSetSet_New();
@@ -720,14 +700,14 @@ static Boolean EvalENodeExpr(LocationSetSet *set, Object *proc, ENode *Int, Stac
while (Int && Int->type == ETYPCON)
Int = Int->data.monadic;
- IRO_ASSERT(Int != NULL);
+ IRO_ASSERT(0, Int != NULL);
if (IRO_IsAssignOp[Int->type]) {
if (Int->type == EPOSTINC || Int->type == EPOSTDEC || Int->type == EPREINC || Int->type == EPREDEC)
indirect = Int->data.monadic;
else
indirect = Int->data.diadic.left;
- IRO_ASSERT(indirect->type == EINDIRECT);
+ IRO_ASSERT(0, indirect->type == EINDIRECT);
lss2 = LocationSetSet_New();
LocationSetSet_Init(lss2);
@@ -787,7 +767,7 @@ static Boolean EvalENodeExpr(LocationSetSet *set, Object *proc, ENode *Int, Stac
// IRO_ASSERT(addr->objRefs->element->type == IROLinearOperand);
// IRO_ASSERT(addr->objRefs->element->u.node->type == EOBJREF);
obj = ((ENode *) addr->objRefs->element)->data.objref;
- IRO_ASSERT(obj != NULL);
+ IRO_ASSERT(0, obj != NULL);
result |= EvalENodeExpr(lss, proc, addr->objRefs->element, stackPtr, map, ptf);
flag2 = 1;
}
@@ -896,7 +876,7 @@ static Boolean EvalENodeExpr(LocationSetSet *set, Object *proc, ENode *Int, Stac
addend = list->element;
if (addend) {
- IRO_ASSERT(addend->type == EINTCONST);
+ IRO_ASSERT(0, addend->type == EINTCONST);
value = CInt64_Add(value, addend->data.intval);
}
@@ -943,7 +923,7 @@ static Boolean EvalENodeExpr(LocationSetSet *set, Object *proc, ENode *Int, Stac
thing = Int;
} else if (Int->type == EOBJREF) {
obj = Int->data.objref;
- IRO_ASSERT(obj != NULL);
+ IRO_ASSERT(0, obj != NULL);
if (ObjectIsAnExtendedParamCandidate(obj)) {
kind = PAMEMORYBLOCKKIND_EXTENDEDPARAM;
thing = CreateExtendedParam(stackPtr, map, obj, &result);
@@ -977,12 +957,10 @@ static Boolean EvalENodeExpr(LocationSetSet *set, Object *proc, ENode *Int, Stac
LocationSetSet_Init(lss2);
result |= EvalENodeExpr(lss2, proc, Int->data.monadic, stackPtr, map, ptf);
- if (LocationSetSet_Count(lss2) == 1 && (ls = LocationSetSet_FindFirst(lss2))) {
+ if (LocationSetSet_Count(lss2) == 1 && (ls = LocationSetSet_FindFirst(lss2)))
LocationSetSet_AddUnknown(lss, NULL, NULL, ls);
- } else {
-#line 2146
- CError_FATAL();
- }
+ else
+ CError_FATAL(2146);
LocationSetSet_Term(lss2);
LocationSetSet_Delete(lss2);
@@ -1064,9 +1042,8 @@ static Boolean EvalVariable(LocationSetSet *set, Object *proc, VarRecord *var, P
}
static void StoreReturnedLocationsAction(LocationSet *loc, void *refcon) {
-#line 2275
- IRO_ASSERT(loc != NULL);
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(2275, loc != NULL);
+ IRO_ASSERT(2276, refcon != NULL);
if (!LocationSet_IsUnknown(loc)) {
if (PAMemoryBlock_kind(LocationSet_block(loc)) == PAMEMORYBLOCKKIND_HEAPBLOCK) {
@@ -1095,11 +1072,10 @@ static void StoreReturnedLocations(IROLinear *nd, PartialTransferFunction *ptf,
LocationSet *retLoc;
LocationSetSet *retLocs;
-#line 2307
- IRO_ASSERT(nd != NULL);
- IRO_ASSERT(nd->type == IROLinearFunccall);
- IRO_ASSERT(ptf != NULL);
- IRO_ASSERT(map != NULL);
+ IRO_ASSERT(2307, nd != NULL);
+ IRO_ASSERT(2308, nd->type == IROLinearFunccall);
+ IRO_ASSERT(2309, ptf != NULL);
+ IRO_ASSERT(2310, map != NULL);
retLoc = PartialTransferFunction_returnLocation(ptf);
retLocs = nd->u.funccall.returnedLocs;
@@ -1133,19 +1109,17 @@ static void FillInAppropriateMappingsWithExtParamAction(Object *obj, void *refco
EPParams *params;
ParamMapping *mapping;
-#line 2352
- IRO_ASSERT(obj != NULL);
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(2352, obj != NULL);
+ IRO_ASSERT(2353, refcon != NULL);
params = refcon;
-#line 2357
- IRO_ASSERT(params->map != NULL);
- IRO_ASSERT(params->ep != NULL);
- IRO_ASSERT(params->proc == NULL || params->proc != NULL);
- IRO_ASSERT(params->proc != &stUnknown);
- IRO_ASSERT(params->var == NULL || params->var != NULL);
- IRO_ASSERT(params->var != &stUnknown);
+ IRO_ASSERT(2357, params->map != NULL);
+ IRO_ASSERT(2358, params->ep != NULL);
+ IRO_ASSERT(2359, params->proc == NULL || params->proc != NULL);
+ IRO_ASSERT(2360, params->proc != &stUnknown);
+ IRO_ASSERT(2361, params->var == NULL || params->var != NULL);
+ IRO_ASSERT(2362, params->var != &stUnknown);
mapping = ParamMappingFunction_FindMappingByFormal(params->map, obj);
if (!mapping) {
@@ -1172,13 +1146,12 @@ static Boolean FillInAppropriateMappingsWithExtParam(ParamMappingFunction *map,
EPParams params;
ObjectSet *objSet;
-#line 2398
- IRO_ASSERT(map != NULL);
- IRO_ASSERT(var == NULL || var != NULL);
- IRO_ASSERT(var != &stUnknown);
- IRO_ASSERT(ep != NULL);
- IRO_ASSERT(proc == NULL || proc != NULL);
- IRO_ASSERT(proc != &stUnknown);
+ IRO_ASSERT(2398, map != NULL);
+ IRO_ASSERT(2399, var == NULL || var != NULL);
+ IRO_ASSERT(2400, var != &stUnknown);
+ IRO_ASSERT(2401, ep != NULL);
+ IRO_ASSERT(2402, proc == NULL || proc != NULL);
+ IRO_ASSERT(2403, proc != &stUnknown);
memset(¶ms, 0, sizeof(params));
params.map = map;
@@ -1205,24 +1178,20 @@ static void MatchPTFHelper(LocationSet *loc, LocationSetSet *locs, Object *proc,
PAMemoryBlockKind kind;
Object *obj;
-#line 2448
- IRO_ASSERT(loc != NULL);
- IRO_ASSERT(!LocationSet_IsUnknown(loc));
- IRO_ASSERT(locs != NULL);
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(map != NULL);
- IRO_ASSERT(ptf != NULL);
+ IRO_ASSERT(2448, loc != NULL);
+ IRO_ASSERT(2449, !LocationSet_IsUnknown(loc));
+ IRO_ASSERT(2450, locs != NULL);
+ IRO_ASSERT(2451, proc != NULL);
+ IRO_ASSERT(2452, map != NULL);
+ IRO_ASSERT(2453, ptf != NULL);
initial = PartialTransferFunction_initialPointsToFn(ptf);
-#line 2456
- IRO_ASSERT(initial != NULL);
+ IRO_ASSERT(2456, initial != NULL);
-#line 2458
- IRO_ASSERT(!LocationSet_IsUnknown(loc));
+ IRO_ASSERT(2458, !LocationSet_IsUnknown(loc));
block = LocationSet_block(loc);
-#line 2460
- IRO_ASSERT(block != NULL);
+ IRO_ASSERT(2460, block != NULL);
kind = PAMemoryBlock_kind(block);
@@ -1230,8 +1199,7 @@ static void MatchPTFHelper(LocationSet *loc, LocationSetSet *locs, Object *proc,
PALocalVar *local;
local = PAMemoryBlock_thing(block);
-#line 2466
- IRO_ASSERT(local != NULL);
+ IRO_ASSERT(2466, local != NULL);
obj = GetLocalObject(local, proc, 1);
if (obj && ObjectIsAFunctionArgument(proc, obj)) {
@@ -1255,16 +1223,14 @@ static void MatchPTFHelper(LocationSet *loc, LocationSetSet *locs, Object *proc,
}
} else if (kind == PAMEMORYBLOCKKIND_EXTENDEDPARAM) {
void *ep = PAMemoryBlock_thing(block);
-#line 2489
- IRO_ASSERT(ep != NULL);
+ IRO_ASSERT(2489, ep != NULL);
obj = NULL;
ObjectSet_ForEach(ExtendedParam_objectSet(ep), FindGlobalObjectAction, &obj);
if (obj && obj != &stUnknown)
FillInAppropriateMappingsWithExtParam(map, obj, ep, proc);
} else {
-#line 2500
- CError_FATAL();
+ CError_FATAL(2500);
}
if (!PointsToFunction_FindByLookupCompatibleLocationSet(initial, loc)) {
@@ -1296,16 +1262,14 @@ static void MatchPTFAction1(PointsToEntry *tgtPTE, void *refcon) {
PAMemoryBlock *block;
PAMemoryBlockKind kind;
-#line 2525
- IRO_ASSERT(tgtPTE != NULL);
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(2525, tgtPTE != NULL);
+ IRO_ASSERT(2526, refcon != NULL);
params = refcon;
-#line 2530
- IRO_ASSERT(params->proc != NULL);
- IRO_ASSERT(params->ptfCopy != NULL);
- IRO_ASSERT(params->mapCopy != NULL);
+ IRO_ASSERT(2530, params->proc != NULL);
+ IRO_ASSERT(2531, params->ptfCopy != NULL);
+ IRO_ASSERT(2532, params->mapCopy != NULL);
if ((loc = PointsToEntry_loc(tgtPTE)) && (locs = PointsToEntry_locs(tgtPTE))) {
if ((block = LocationSet_block(loc))) {
@@ -1313,8 +1277,7 @@ static void MatchPTFAction1(PointsToEntry *tgtPTE, void *refcon) {
if (kind == PAMEMORYBLOCKKIND_LOCALVAR) {
MatchPTFHelper(loc, locs, params->proc, params->mapCopy, params->ptfCopy);
} else if (kind != PAMEMORYBLOCKKIND_EXTENDEDPARAM) {
-#line 2547
- CError_FATAL();
+ CError_FATAL(2547);
}
}
}
@@ -1327,16 +1290,14 @@ static void MatchPTFAction2(PointsToEntry *tgtPTE, void *refcon) {
PAMemoryBlock *block;
PAMemoryBlockKind kind;
-#line 2561
- IRO_ASSERT(tgtPTE != NULL);
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(2561, tgtPTE != NULL);
+ IRO_ASSERT(2562, refcon != NULL);
params = refcon;
-#line 2566
- IRO_ASSERT(params->proc != NULL);
- IRO_ASSERT(params->ptfCopy != NULL);
- IRO_ASSERT(params->mapCopy != NULL);
+ IRO_ASSERT(2566, params->proc != NULL);
+ IRO_ASSERT(2567, params->ptfCopy != NULL);
+ IRO_ASSERT(2568, params->mapCopy != NULL);
if ((loc = PointsToEntry_loc(tgtPTE)) && (locs = PointsToEntry_locs(tgtPTE))) {
if ((block = LocationSet_block(loc))) {
@@ -1355,12 +1316,11 @@ static Boolean MatchPTF(PartialTransferFunction *tgtPTF, Object *proc, ParamMapp
PointsToFunction *initial;
MatchPTFActionParams params;
-#line 2593
- IRO_ASSERT(tgtPTF != NULL);
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(map != NULL);
- IRO_ASSERT(nd != NULL);
- IRO_ASSERT(ptf != NULL);
+ IRO_ASSERT(2593, tgtPTF != NULL);
+ IRO_ASSERT(2594, proc != NULL);
+ IRO_ASSERT(2595, map != NULL);
+ IRO_ASSERT(2596, nd != NULL);
+ IRO_ASSERT(2597, ptf != NULL);
ptfCopy = PartialTransferFunction_New();
PartialTransferFunction_Copy(ptfCopy, ptf);
@@ -1401,9 +1361,8 @@ static Boolean MatchPTF(PartialTransferFunction *tgtPTF, Object *proc, ParamMapp
static void FindCallTargetsAction2(Object *obj, void *refcon) {
ObjectSet *procList;
-#line 2650
- IRO_ASSERT(obj != NULL);
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(2650, obj != NULL);
+ IRO_ASSERT(2651, refcon != NULL);
procList = refcon;
@@ -1414,9 +1373,8 @@ static void FindCallTargetsAction2(Object *obj, void *refcon) {
static void FindCallTargetsAction(LocationSet *ls, void *refcon) {
ObjectSet *procList;
-#line 2669
- IRO_ASSERT(ls != NULL);
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(2669, ls != NULL);
+ IRO_ASSERT(2670, refcon != NULL);
procList = refcon;
@@ -1437,13 +1395,12 @@ static int FindCallTargets(ObjectSet *procList, Object *proc, IROLinear *nd, Par
int evalResult;
int result;
-#line 2696
- IRO_ASSERT(procList != NULL);
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(nd != NULL);
- IRO_ASSERT(nd->type == IROLinearFunccall);
- IRO_ASSERT(map != NULL);
- IRO_ASSERT(ptf != NULL);
+ IRO_ASSERT(2696, procList != NULL);
+ IRO_ASSERT(2697, proc != NULL);
+ IRO_ASSERT(2698, nd != NULL);
+ IRO_ASSERT(2699, nd->type == IROLinearFunccall);
+ IRO_ASSERT(2700, map != NULL);
+ IRO_ASSERT(2701, ptf != NULL);
set = LocationSetSet_New();
LocationSetSet_Init(set);
@@ -1460,14 +1417,13 @@ static int LookupParam(LocationSetSet *set, LocationSet *ls, Object *var, Stack
Boolean result;
ExtendedParam *ep;
-#line 2728
- IRO_ASSERT(set == NULL || set != NULL);
- IRO_ASSERT(ls != NULL);
- IRO_ASSERT(var != NULL);
- IRO_ASSERT(stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(map == NULL || map != NULL);
- IRO_ASSERT(ptf == NULL || ptf != NULL);
+ IRO_ASSERT(2728, set == NULL || set != NULL);
+ IRO_ASSERT(2729, ls != NULL);
+ IRO_ASSERT(2730, var != NULL);
+ IRO_ASSERT(2731, stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
+ IRO_ASSERT(2732, proc != NULL);
+ IRO_ASSERT(2733, map == NULL || map != NULL);
+ IRO_ASSERT(2734, ptf == NULL || ptf != NULL);
result = 0;
@@ -1475,8 +1431,7 @@ static int LookupParam(LocationSetSet *set, LocationSet *ls, Object *var, Stack
if (!ep)
ep = CreateExtendedParam(stackPtr, map, var, &result);
-#line 2741
- IRO_ASSERT(ep != NULL);
+ IRO_ASSERT(2741, ep != NULL);
if (ep) {
PAMemoryBlock *block;
@@ -1547,13 +1502,12 @@ static Boolean GetActualLocsOfExtendedParam(LocationSetSet *set, LocationSet *ls
UInt32 savedStride;
LocationSetSet *newSet;
-#line 2821
- IRO_ASSERT(set == NULL || set != NULL);
- IRO_ASSERT((ls != NULL && var == NULL) || (ls == NULL && var != NULL));
- IRO_ASSERT(ls == NULL || !LocationSet_IsUnknown(ls));
- IRO_ASSERT(var != &stUnknown);
- IRO_ASSERT(stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
- IRO_ASSERT(map == NULL || map != NULL);
+ IRO_ASSERT(2821, set == NULL || set != NULL);
+ IRO_ASSERT(2822, (ls != NULL && var == NULL) || (ls == NULL && var != NULL));
+ IRO_ASSERT(2823, ls == NULL || !LocationSet_IsUnknown(ls));
+ IRO_ASSERT(2824, var != &stUnknown);
+ IRO_ASSERT(2825, stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
+ IRO_ASSERT(2826, map == NULL || map != NULL);
result = 0;
block = NULL;
@@ -1563,21 +1517,18 @@ static Boolean GetActualLocsOfExtendedParam(LocationSetSet *set, LocationSet *ls
if (ls) {
block = LocationSet_block(ls);
-#line 2838
- IRO_ASSERT(block != NULL);
- IRO_ASSERT(PAMemoryBlock_kind(block) == PAMEMORYBLOCKKIND_EXTENDEDPARAM);
+ IRO_ASSERT(2838, block != NULL);
+ IRO_ASSERT(2839, PAMemoryBlock_kind(block) == PAMEMORYBLOCKKIND_EXTENDEDPARAM);
ep = PAMemoryBlock_thing(block);
-#line 2842
- IRO_ASSERT(ep != NULL);
+ IRO_ASSERT(2842, ep != NULL);
savedField = LocationSet_field(ls);
savedStride = LocationSet_stride(ls);
savedRtype = LocationSet_rtype(ls);
}
-#line 2848
- IRO_ASSERT(ep == NULL || ep != NULL);
+ IRO_ASSERT(2848, ep == NULL || ep != NULL);
if (stackPtr && *stackPtr) {
StackElement *element = Stack_Top(stackPtr);
@@ -1585,12 +1536,10 @@ static Boolean GetActualLocsOfExtendedParam(LocationSetSet *set, LocationSet *ls
map = StackElement_map(element);
}
-#line 2859
- IRO_ASSERT(map == NULL || map != NULL);
+ IRO_ASSERT(2859, map == NULL || map != NULL);
if (ep) {
-#line 2863
- IRO_ASSERT(var == NULL);
+ IRO_ASSERT(2863, var == NULL);
ObjectSet_ForEach(ExtendedParam_objectSet(ep), FindGlobalObjectAction, &var);
if (!var)
var = ObjectSet_FindFirst(ExtendedParam_objectSet(ep));
@@ -1598,8 +1547,7 @@ static Boolean GetActualLocsOfExtendedParam(LocationSetSet *set, LocationSet *ls
var = &stUnknown;
}
-#line 2870
- IRO_ASSERT(var != NULL);
+ IRO_ASSERT(2870, var != NULL);
if (map && var != &stUnknown) {
if (flag)
@@ -1610,17 +1558,15 @@ static Boolean GetActualLocsOfExtendedParam(LocationSetSet *set, LocationSet *ls
newSet = LocationSetSet_New();
LocationSetSet_Init(newSet);
-#line 2884
- IRO_ASSERT(mapping == NULL || mapping != NULL);
+ IRO_ASSERT(2884, mapping == NULL || mapping != NULL);
if (mapping)
nd = ParamMapping_actual(mapping);
if (!nd) {
if (!ls) {
-#line 2893
- IRO_ASSERT(var != NULL);
- IRO_ASSERT(ep == NULL);
+ IRO_ASSERT(2893, var != NULL);
+ IRO_ASSERT(2894, ep == NULL);
if (var != &stUnknown) {
ep = CreateExtendedParam(stackPtr, NULL, var, &result);
@@ -1643,8 +1589,7 @@ static Boolean GetActualLocsOfExtendedParam(LocationSetSet *set, LocationSet *ls
savedRtype = NULL;
}
-#line 2925
- IRO_ASSERT(block != NULL);
+ IRO_ASSERT(2925, block != NULL);
if (block == LocationSet_block(stUnknownLs)) {
LocationSetSet_AddUnknown(newSet, savedRtype, NULL, NULL);
@@ -1718,17 +1663,15 @@ typedef struct ExpandLocationSetSetActionParams {
static void ExpandLocationSetSetToActualsAction(LocationSet *ls, void *refcon) {
ExpandLocationSetSetActionParams *params;
-#line 3021
- IRO_ASSERT(ls != NULL);
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(3021, ls != NULL);
+ IRO_ASSERT(3022, refcon != NULL);
params = refcon;
-#line 3026
- IRO_ASSERT(params->toBeRemoved != NULL);
- IRO_ASSERT(params->toBeAdded != NULL);
- IRO_ASSERT(params->stackPtr == NULL || *params->stackPtr == NULL || *params->stackPtr != NULL);
- IRO_ASSERT(params->map == NULL || params->map != NULL);
+ IRO_ASSERT(3026, params->toBeRemoved != NULL);
+ IRO_ASSERT(3027, params->toBeAdded != NULL);
+ IRO_ASSERT(3028, params->stackPtr == NULL || *params->stackPtr == NULL || *params->stackPtr != NULL);
+ IRO_ASSERT(3029, params->map == NULL || params->map != NULL);
if (!LocationSet_IsUnknown(ls)) {
PAMemoryBlock *block = LocationSet_block(ls);
@@ -1753,10 +1696,9 @@ static int ExpandLocationSetSetToActuals(Stack **stackPtr, ParamMappingFunction
ExpandLocationSetSetActionParams params;
Boolean result;
-#line 3063
- IRO_ASSERT(stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
- IRO_ASSERT(map == NULL || map != NULL);
- IRO_ASSERT(thingsPointedTo != NULL);
+ IRO_ASSERT(3063, stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
+ IRO_ASSERT(3064, map == NULL || map != NULL);
+ IRO_ASSERT(3065, thingsPointedTo != NULL);
toBeRemoved = LocationSetSet_New();
LocationSetSet_Init(toBeRemoved);
@@ -1791,15 +1733,13 @@ static void EvaluatePartialAbsolute(LocationSetSet *set, LocationSetSet *thingsP
Type *absLocRtype;
PAMemoryBlock *block;
-#line 3108
- IRO_ASSERT(set != NULL);
- IRO_ASSERT(thingsPointedTo != NULL);
- IRO_ASSERT(dst != NULL);
- IRO_ASSERT(indRtype != NULL);
+ IRO_ASSERT(3108, set != NULL);
+ IRO_ASSERT(3109, thingsPointedTo != NULL);
+ IRO_ASSERT(3110, dst != NULL);
+ IRO_ASSERT(3111, indRtype != NULL);
absLoc = LocationSetSet_FindFirst(thingsPointedTo);
-#line 3114
- IRO_ASSERT(absLoc != NULL);
+ IRO_ASSERT(3114, absLoc != NULL);
if (!LocationSet_IsUnknown(absLoc))
absLocRtype = LocationSet_rtype(absLoc);
@@ -1862,10 +1802,9 @@ static Boolean AddToInitialPointsToFunc(Boolean flag, PartialTransferFunction *p
PointsToFunction *initial;
PointsToEntry *pte;
-#line 3192
- IRO_ASSERT(ptf == NULL || ptf != NULL);
- IRO_ASSERT(dst != NULL);
- IRO_ASSERT(set != NULL);
+ IRO_ASSERT(3192, ptf == NULL || ptf != NULL);
+ IRO_ASSERT(3193, dst != NULL);
+ IRO_ASSERT(3194, set != NULL);
result = 0;
@@ -1874,8 +1813,7 @@ static Boolean AddToInitialPointsToFunc(Boolean flag, PartialTransferFunction *p
if (!ls || LocationSet_rtype(ls)) {
initial = PartialTransferFunction_initialPointsToFn(ptf);
if (initial && !PointsToFunction_FindByLookupCompatibleLocationSet(initial, dst)) {
-#line 3208
- IRO_ASSERT(dst != NULL);
+ IRO_ASSERT(3208, dst != NULL);
pte = PointsToEntry_New();
PointsToEntry_Init(pte, dst, set);
@@ -1899,15 +1837,14 @@ static Boolean Lookup(LocationSetSet *set, Stack **stackPtr, Object *proc, Param
ObjectSet *objSet;
Object *obj;
-#line 3245
- IRO_ASSERT(set == NULL || set != NULL);
- IRO_ASSERT(stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
- IRO_ASSERT(proc == NULL || proc != NULL);
- IRO_ASSERT(map == NULL || map != NULL);
- IRO_ASSERT(ptf == NULL || ptf != NULL);
- IRO_ASSERT(dst != NULL);
- IRO_ASSERT(pointsToFunc == NULL || pointsToFunc != NULL);
- IRO_ASSERT(indRtype == NULL || indRtype != NULL);
+ IRO_ASSERT(3245, set == NULL || set != NULL);
+ IRO_ASSERT(3246, stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
+ IRO_ASSERT(3247, proc == NULL || proc != NULL);
+ IRO_ASSERT(3248, map == NULL || map != NULL);
+ IRO_ASSERT(3249, ptf == NULL || ptf != NULL);
+ IRO_ASSERT(3250, dst != NULL);
+ IRO_ASSERT(3251, pointsToFunc == NULL || pointsToFunc != NULL);
+ IRO_ASSERT(3252, indRtype == NULL || indRtype != NULL);
result = 0;
@@ -2028,9 +1965,8 @@ static Boolean Lookup(LocationSetSet *set, Stack **stackPtr, Object *proc, Param
}
static Boolean InputsHaveNewPointerValues(PartialTransferFunction *tgtPTF, PartialTransferFunction *ptf) {
-#line 3393
- IRO_ASSERT(tgtPTF != NULL);
- IRO_ASSERT(ptf != NULL);
+ IRO_ASSERT(3393, tgtPTF != NULL);
+ IRO_ASSERT(3394, ptf != NULL);
return 0;
}
@@ -2055,14 +1991,13 @@ static void CreateExtendedParamAction(ParamMapping *mapping, void *refcon) {
ExtendedParam *lastEP;
uint32 lastValue;
-#line 3417
- IRO_ASSERT(mapping != NULL);
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(3417, mapping != NULL);
+ IRO_ASSERT(3418, refcon != NULL);
params = refcon;
- IRO_ASSERT(params->last == NULL || params->last != NULL);
- IRO_ASSERT(params->lowest == NULL || params->lowest != NULL);
+ IRO_ASSERT(3422, params->last == NULL || params->last != NULL);
+ IRO_ASSERT(3423, params->lowest == NULL || params->lowest != NULL);
if ((ep = ParamMapping_extended(mapping))) {
value = ExtendedParam_sub_489110(ep);
@@ -2093,11 +2028,10 @@ static ExtendedParam *FindMatchingExtendedParam(Stack **stackPtr, ParamMappingFu
ExtendedParam *ep;
ExtendedParam *lowestEP;
-#line 3473
- IRO_ASSERT(stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
- IRO_ASSERT(map == NULL || map != NULL);
- IRO_ASSERT(lss != NULL);
- IRO_ASSERT(lowest != NULL);
+ IRO_ASSERT(3473, stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
+ IRO_ASSERT(3474, map == NULL || map != NULL);
+ IRO_ASSERT(3475, lss != NULL);
+ IRO_ASSERT(3476, lowest != NULL);
ep = NULL;
if ((lowestEP = ParamMapping_extended(lowest))) {
@@ -2134,10 +2068,9 @@ static ExtendedParam *CreateExtendedParam(Stack **stackPtr, ParamMappingFunction
LocationSetSet *lss;
CreateEPActionParams params;
-#line 3518
- IRO_ASSERT(map == NULL || map != NULL);
- IRO_ASSERT(stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
- IRO_ASSERT(var != NULL);
+ IRO_ASSERT(3518, map == NULL || map != NULL);
+ IRO_ASSERT(3519, stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
+ IRO_ASSERT(3520, var != NULL);
mapping = NULL;
if (map)
@@ -2145,10 +2078,8 @@ static ExtendedParam *CreateExtendedParam(Stack **stackPtr, ParamMappingFunction
ep = ExtendedParam_FindByObject(var);
if (ep) {
- if (mapping) {
-#line 3535
- IRO_ASSERT(ep == ParamMapping_extended(mapping) || ParamMapping_extended(mapping) == NULL);
- }
+ if (mapping)
+ IRO_ASSERT(3535, ep == ParamMapping_extended(mapping) || ParamMapping_extended(mapping) == NULL);
} else if (map && !ObjectIsRestrictQualified(var)) {
lss = LocationSetSet_New();
LocationSetSet_Init(lss);
@@ -2181,26 +2112,23 @@ static ExtendedParam *CreateExtendedParam(Stack **stackPtr, ParamMappingFunction
if (stExtParamSet)
ExtParamSet_sub_487630(stExtParamSet, ep);
-#line 3583
- IRO_ASSERT(ep != NULL);
+ IRO_ASSERT(3583, ep != NULL);
return ep;
}
#ifdef IRO_DEBUG
void __assertion_failed(char *expr, char *filename, int line) {
-#line 3605
- CError_ASSERT(filename);
+ CError_ASSERT(3605, filename);
CError_Internal(filename, line);
}
#endif
static void RecordActuals(IROLinear *nd, Object *proc, ParamMappingFunction *map) {
-#line 3628
- IRO_ASSERT(nd != NULL);
- IRO_ASSERT(nd->type == IROLinearFunccall);
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(map != NULL);
+ IRO_ASSERT(3628, nd != NULL);
+ IRO_ASSERT(3629, nd->type == IROLinearFunccall);
+ IRO_ASSERT(3630, proc != NULL);
+ IRO_ASSERT(3631, map != NULL);
if (proc != &stUnknown) {
int i;
@@ -2214,8 +2142,7 @@ static void RecordActuals(IROLinear *nd, Object *proc, ParamMappingFunction *map
arg = &stUnknown;
for (i = 0; i < nd->u.funccall.argCount; i++) {
-#line 3643
- IRO_ASSERT(arg != NULL);
+ IRO_ASSERT(3643, arg != NULL);
if (arg != &stUnknown) {
ParamMapping *mapping = ParamMapping_New();
@@ -2237,10 +2164,9 @@ static void RecordActuals(IROLinear *nd, Object *proc, ParamMappingFunction *map
}
static Boolean IsAddressableLocation(LocationSet *loc, Object *proc, IRONode *fnode, IROLinear *nd) {
-#line 3676
- IRO_ASSERT(loc != NULL);
- IRO_ASSERT(fnode != NULL);
- IRO_ASSERT(nd != NULL);
+ IRO_ASSERT(3676, loc != NULL);
+ IRO_ASSERT(3677, fnode != NULL);
+ IRO_ASSERT(3678, nd != NULL);
if (!LocationSet_IsUnknown(loc)) {
PAMemoryBlock *block;
@@ -2277,9 +2203,8 @@ static Boolean IsAddressableLocation(LocationSet *loc, Object *proc, IRONode *fn
}
static Boolean LocationSetsAlias(LocationSet *ls1, LocationSet *ls2) {
-#line 3719
- IRO_ASSERT(ls1 != NULL);
- IRO_ASSERT(ls2 != NULL);
+ IRO_ASSERT(3719, ls1 != NULL);
+ IRO_ASSERT(3720, ls2 != NULL);
return
(ls1 == ls2) ||
@@ -2319,9 +2244,8 @@ static void FindAliasingAction2(LocationSet *ls, void *refcon) {
static void FindAliasingAction(LocationSet *ls, void *refcon) {
FindAliasingParams *params;
-#line 3751
- IRO_ASSERT(ls != NULL);
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(3751, ls != NULL);
+ IRO_ASSERT(3752, refcon != NULL);
params = refcon;
@@ -2351,24 +2275,21 @@ static void KillAllAddressableLocationsAction(PointsToEntry *pte, void *refcon)
KillLocationParams *params;
LocationSet *loc;
-#line 3779
- IRO_ASSERT(pte != NULL);
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(3779, pte != NULL);
+ IRO_ASSERT(3780, refcon != NULL);
params = refcon;
-#line 3784
- IRO_ASSERT(params->proc != NULL);
- IRO_ASSERT(params->fnode != NULL);
- IRO_ASSERT(params->nd != NULL);
- IRO_ASSERT(params->ptf != NULL);
- IRO_ASSERT(params->toBeKilled != NULL);
- IRO_ASSERT(params->dst == NULL);
+ IRO_ASSERT(3784, params->proc != NULL);
+ IRO_ASSERT(3785, params->fnode != NULL);
+ IRO_ASSERT(3786, params->nd != NULL);
+ IRO_ASSERT(3787, params->ptf != NULL);
+ IRO_ASSERT(3788, params->toBeKilled != NULL);
+ IRO_ASSERT(3789, params->dst == NULL);
loc = PointsToEntry_loc(pte);
-#line 3793
- IRO_ASSERT(loc != NULL);
- IRO_ASSERT(!LocationSet_IsUnknown(loc));
+ IRO_ASSERT(3793, loc != NULL);
+ IRO_ASSERT(3794, !LocationSet_IsUnknown(loc));
if (IsAddressableLocation(loc, params->proc, params->fnode, params->nd))
PointsToFunction_Add(params->toBeKilled, pte);
@@ -2378,26 +2299,23 @@ static void KillAllAliasingExtParamLocsAction(PointsToEntry *pte, void *refcon)
KillLocationParams *params;
LocationSet *loc;
-#line 3813
- IRO_ASSERT(pte != NULL);
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(3813, pte != NULL);
+ IRO_ASSERT(3814, refcon != NULL);
params = refcon;
-#line 3818
- IRO_ASSERT(params->proc != NULL);
- IRO_ASSERT(params->fnode != NULL);
- IRO_ASSERT(params->nd != NULL);
- IRO_ASSERT(params->ptf != NULL);
- IRO_ASSERT(params->toBeKilled != NULL);
- IRO_ASSERT(params->dst != NULL);
- IRO_ASSERT(LocationSet_block(params->dst) != NULL);
- IRO_ASSERT(PAMemoryBlock_kind(LocationSet_block(params->dst)) == PAMEMORYBLOCKKIND_EXTENDEDPARAM);
+ IRO_ASSERT(3818, params->proc != NULL);
+ IRO_ASSERT(3819, params->fnode != NULL);
+ IRO_ASSERT(3820, params->nd != NULL);
+ IRO_ASSERT(3821, params->ptf != NULL);
+ IRO_ASSERT(3822, params->toBeKilled != NULL);
+ IRO_ASSERT(3823, params->dst != NULL);
+ IRO_ASSERT(3824, LocationSet_block(params->dst) != NULL);
+ IRO_ASSERT(3825, PAMemoryBlock_kind(LocationSet_block(params->dst)) == PAMEMORYBLOCKKIND_EXTENDEDPARAM);
loc = PointsToEntry_loc(pte);
-#line 3829
- IRO_ASSERT(loc != NULL);
- IRO_ASSERT(!LocationSet_IsUnknown(loc));
+ IRO_ASSERT(3829, loc != NULL);
+ IRO_ASSERT(3830, !LocationSet_IsUnknown(loc));
if (loc != params->dst) {
if (LocationSetsAlias(loc, params->dst)) {
@@ -2452,24 +2370,21 @@ static void KillLocationsAction(PointsToEntry *pte, void *refcon) {
LocationSet *loc;
LocationSetSet *lss;
-#line 3886
- IRO_ASSERT(pte != NULL);
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(3886, pte != NULL);
+ IRO_ASSERT(3887, refcon != NULL);
params = refcon;
-#line 3891
- IRO_ASSERT(params->proc != NULL);
- IRO_ASSERT(params->fnode != NULL);
- IRO_ASSERT(params->nd != NULL);
- IRO_ASSERT(params->ptf != NULL);
- IRO_ASSERT(params->toBeKilled != NULL);
- IRO_ASSERT(params->dst == NULL);
+ IRO_ASSERT(3891, params->proc != NULL);
+ IRO_ASSERT(3892, params->fnode != NULL);
+ IRO_ASSERT(3893, params->nd != NULL);
+ IRO_ASSERT(3894, params->ptf != NULL);
+ IRO_ASSERT(3895, params->toBeKilled != NULL);
+ IRO_ASSERT(3896, params->dst == NULL);
loc = PointsToEntry_loc(pte);
-#line 3900
- IRO_ASSERT(loc != NULL);
- IRO_ASSERT(!LocationSet_IsUnknown(loc));
+ IRO_ASSERT(3900, loc != NULL);
+ IRO_ASSERT(3901, !LocationSet_IsUnknown(loc));
lss = LocationSetSet_New();
LocationSetSet_Init(lss);
@@ -2488,11 +2403,10 @@ static Boolean KillAllAddressableLocations(Object *proc, IRONode *fnode, IROLine
PointsToFunction *toBeKilled;
KillLocationParams params;
-#line 3921
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(fnode == NULL || fnode != NULL);
- IRO_ASSERT(nd == NULL || nd != NULL);
- IRO_ASSERT(ptf != NULL);
+ IRO_ASSERT(3921, proc != NULL);
+ IRO_ASSERT(3922, fnode == NULL || fnode != NULL);
+ IRO_ASSERT(3923, nd == NULL || nd != NULL);
+ IRO_ASSERT(3924, ptf != NULL);
if (nd && nd->pointsToFunction)
pointsToFunc = nd->pointsToFunction;
@@ -2538,12 +2452,11 @@ static void KillAllAliasingExtParamLocs(Object *proc, IRONode *fnode, IROLinear
PointsToFunction *toBeKilled;
KillLocationParams params;
-#line 3974
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(fnode == NULL || fnode != NULL);
- IRO_ASSERT(nd == NULL || nd != NULL);
- IRO_ASSERT(ptf != NULL);
- IRO_ASSERT(dst != NULL);
+ IRO_ASSERT(3974, proc != NULL);
+ IRO_ASSERT(3975, fnode == NULL || fnode != NULL);
+ IRO_ASSERT(3976, nd == NULL || nd != NULL);
+ IRO_ASSERT(3977, ptf != NULL);
+ IRO_ASSERT(3978, dst != NULL);
if (!LocationSet_IsUnknown(dst) && LocationSet_block(dst)) {
if (PAMemoryBlock_kind(LocationSet_block(dst)) == PAMEMORYBLOCKKIND_EXTENDEDPARAM) {
@@ -2585,13 +2498,12 @@ static Boolean Assign(PartialTransferFunction *ptf, LocationSet *dst, LocationSe
LocationSet *bitfieldOf;
LocationSetSet *lss;
-#line 4027
- IRO_ASSERT(ptf != NULL);
- IRO_ASSERT(dst != NULL);
- IRO_ASSERT(srcs != NULL);
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(nd == NULL || nd != NULL);
- IRO_ASSERT(fnode == NULL || fnode != NULL);
+ IRO_ASSERT(4027, ptf != NULL);
+ IRO_ASSERT(4028, dst != NULL);
+ IRO_ASSERT(4029, srcs != NULL);
+ IRO_ASSERT(4030, proc != NULL);
+ IRO_ASSERT(4031, nd == NULL || nd != NULL);
+ IRO_ASSERT(4032, fnode == NULL || fnode != NULL);
if (nd) {
if (!nd->pointsToFunction) {
@@ -2607,9 +2519,8 @@ static Boolean Assign(PartialTransferFunction *ptf, LocationSet *dst, LocationSe
if (pte) {
loc = PointsToEntry_loc(pte);
locs = PointsToEntry_locs(pte);
-#line 4056
- IRO_ASSERT(!LocationSet_IsUnknown(dst));
- IRO_ASSERT(LocationSet_stride(dst) == 0 || LocationSet_stride(loc) != 0);
+ IRO_ASSERT(4056, !LocationSet_IsUnknown(dst));
+ IRO_ASSERT(4057, LocationSet_stride(dst) == 0 || LocationSet_stride(loc) != 0);
result = !LocationSetSets_Equal(srcs, locs) || LocationSet_stride(dst) != LocationSet_stride(loc);
@@ -2665,18 +2576,16 @@ static void EvalMeetAction(PointsToEntry *pte, void *refcon) {
LocationSetSet *set;
UInt16 i;
-#line 4123
- IRO_ASSERT(pte != NULL);
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(4123, pte != NULL);
+ IRO_ASSERT(4124, refcon != NULL);
params = refcon;
-#line 4128
- IRO_ASSERT(params->proc != NULL);
- IRO_ASSERT(params->fnode != NULL);
- IRO_ASSERT(params->pred != NULL);
- IRO_ASSERT(params->nd != NULL);
- IRO_ASSERT(params->ptf != NULL);
+ IRO_ASSERT(4128, params->proc != NULL);
+ IRO_ASSERT(4129, params->fnode != NULL);
+ IRO_ASSERT(4130, params->pred != NULL);
+ IRO_ASSERT(4131, params->nd != NULL);
+ IRO_ASSERT(4132, params->ptf != NULL);
loc = PointsToEntry_loc(pte);
@@ -2701,11 +2610,10 @@ static Boolean EvalMeet(Object *proc, IRONode *fnode, IROLinear *nd, PartialTran
EvalMeetActionParams params;
int i;
-#line 4163
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(fnode != NULL);
- IRO_ASSERT(nd != NULL);
- IRO_ASSERT(ptf != NULL);
+ IRO_ASSERT(4163, proc != NULL);
+ IRO_ASSERT(4164, fnode != NULL);
+ IRO_ASSERT(4165, nd != NULL);
+ IRO_ASSERT(4166, ptf != NULL);
pointsToFunc = PointsToFunction_New();
if (nd->pointsToFunction)
@@ -2745,11 +2653,10 @@ static Boolean EvalMeet(Object *proc, IRONode *fnode, IROLinear *nd, PartialTran
static PartialTransferFunction *AllocatePTF(Object *proc, IROLinear *nd, PartialTransferFunction *ptf) {
PartialTransferFunction *newPTF;
-#line 4210
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(proc->u.func.ptfList != NULL);
- IRO_ASSERT(nd == NULL || nd != NULL);
- IRO_ASSERT(ptf == NULL || ptf != NULL);
+ IRO_ASSERT(4210, proc != NULL);
+ IRO_ASSERT(4211, proc->u.func.ptfList != NULL);
+ IRO_ASSERT(4212, nd == NULL || nd != NULL);
+ IRO_ASSERT(4213, ptf == NULL || ptf != NULL);
newPTF = PartialTransferFunction_New();
PartialTransferFunction_Init(newPTF, nd, ptf);
@@ -2758,8 +2665,7 @@ static PartialTransferFunction *AllocatePTF(Object *proc, IROLinear *nd, Partial
}
static Object *FindMainEntryPoint(Object *function) {
-#line 4229
- IRO_ASSERT(function != NULL);
+ IRO_ASSERT(4229, function != NULL);
return function;
}
@@ -2776,8 +2682,7 @@ static ObjectList *FunctionArguments(Object *proc) {
FuncArg *args;
Boolean notFound;
-#line 4252
- IRO_ASSERT(proc != NULL);
+ IRO_ASSERT(4252, proc != NULL);
if (proc == stCurrentProc) {
for (list = arguments; list; list = list->next) {
@@ -2866,21 +2771,17 @@ static ObjectList *FunctionArguments(Object *proc) {
}
static IRONode **FunctionNodeTable(Object *proc) {
-#line 4383
- IRO_ASSERT(proc != NULL);
+ IRO_ASSERT(4383, proc != NULL);
-#line 4391
- IRO_ASSERT(proc == stCurrentProc);
+ IRO_ASSERT(4391, proc == stCurrentProc);
return IRO_NodeTable;
}
static IRONode *FunctionFirstNode(Object *proc) {
-#line 4401
- IRO_ASSERT(proc != NULL);
+ IRO_ASSERT(4401, proc != NULL);
-#line 4409
- IRO_ASSERT(proc == stCurrentProc);
+ IRO_ASSERT(4409, proc == stCurrentProc);
return IRO_FirstNode;
}
@@ -2914,18 +2815,16 @@ static void EvalCallAction(Object *proc, void *refcon) {
Boolean flag;
Boolean flag2;
-#line 4458
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(4458, proc != NULL);
+ IRO_ASSERT(4459, refcon != NULL);
params = refcon;
-#line 4463
- IRO_ASSERT(params->proc != NULL);
- IRO_ASSERT(params->fnode != NULL);
- IRO_ASSERT(params->nd != NULL);
- IRO_ASSERT(params->ptf != NULL);
- IRO_ASSERT(params->map == NULL || params->map != NULL);
+ IRO_ASSERT(4463, params->proc != NULL);
+ IRO_ASSERT(4464, params->fnode != NULL);
+ IRO_ASSERT(4465, params->nd != NULL);
+ IRO_ASSERT(4466, params->ptf != NULL);
+ IRO_ASSERT(4467, params->map == NULL || params->map != NULL);
if (!params->x18) {
pmf = ParamMappingFunction_New();
@@ -2945,8 +2844,7 @@ static void EvalCallAction(Object *proc, void *refcon) {
StackElement_Term(element);
StackElement_Delete(element);
-#line 4490
- IRO_ASSERT(tgtPTF != NULL);
+ IRO_ASSERT(4490, tgtPTF != NULL);
flag = 1;
@@ -2984,12 +2882,11 @@ static Boolean EvalCall(Object *proc, IRONode *fnode, IROLinear *nd, ParamMappin
EvalCallActionParams params;
ObjectSet *objSet;
-#line 4548
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(fnode != NULL);
- IRO_ASSERT(nd != NULL);
- IRO_ASSERT(map != NULL);
- IRO_ASSERT(ptf != NULL);
+ IRO_ASSERT(4548, proc != NULL);
+ IRO_ASSERT(4549, fnode != NULL);
+ IRO_ASSERT(4550, nd != NULL);
+ IRO_ASSERT(4551, map != NULL);
+ IRO_ASSERT(4552, ptf != NULL);
memset(¶ms, 0, sizeof(params));
params.proc = proc;
@@ -3031,8 +2928,7 @@ static void AdjustTypesForVolatilityAction(LocationSet *ls, void *refcon) {
qual = TYPE_MEMBER_POINTER(type)->qual;
break;
default:
-#line 4604
- CError_FATAL();
+ CError_FATAL(4604);
}
if (!(qual & Q_VOLATILE)) {
@@ -3082,17 +2978,15 @@ static void EvalAssignAction2(LocationSet *ls, void *refcon) {
Type *rtype;
PAMemoryBlock *block;
-#line 4657
- IRO_ASSERT(ls != NULL);
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(4657, ls != NULL);
+ IRO_ASSERT(4658, refcon != NULL);
params = refcon;
if (!params->xC && !LocationSet_IsUnknown(ls)) {
value = params->x0;
nd = params->nd;
-#line 4665
- IRO_ASSERT(nd != NULL);
+ IRO_ASSERT(4665, nd != NULL);
oper = nd->nodetype;
stride = LocationSet_stride(ls);
@@ -3170,8 +3064,7 @@ static void EvalAssignAction2(LocationSet *ls, void *refcon) {
value = CInt64_Or(*((CInt64 *) PAMemoryBlock_thing(block)), value);
break;
default:
-#line 4746
- CError_FATAL();
+ CError_FATAL(4746);
}
block = PAMemoryBlock_New();
@@ -3225,18 +3118,16 @@ static void EvalAssignAction(LocationSet *dst, void *refcon) {
EvalAssignActionParams *params;
LocationSetSet *srcs;
-#line 4797
- IRO_ASSERT(dst != NULL);
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(4797, dst != NULL);
+ IRO_ASSERT(4798, refcon != NULL);
params = refcon;
-#line 4802
- IRO_ASSERT(params->proc != NULL);
- IRO_ASSERT(params->ptf != NULL);
- IRO_ASSERT(params->nd != NULL);
- IRO_ASSERT(params->fnode != NULL);
- IRO_ASSERT(params->srcs != NULL);
+ IRO_ASSERT(4802, params->proc != NULL);
+ IRO_ASSERT(4802, params->ptf != NULL);
+ IRO_ASSERT(4803, params->nd != NULL);
+ IRO_ASSERT(4804, params->fnode != NULL);
+ IRO_ASSERT(4805, params->srcs != NULL);
srcs = params->srcs;
if (
@@ -3264,12 +3155,11 @@ static Boolean EvalAssign(Object *proc, IROLinear *nd, IRONode *fnode, ParamMapp
PAMemoryBlock *block;
Type *type;
-#line 4840
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(nd != NULL);
- IRO_ASSERT(fnode != NULL);
- IRO_ASSERT(map != NULL);
- IRO_ASSERT(ptf != NULL);
+ IRO_ASSERT(4840, proc != NULL);
+ IRO_ASSERT(4841, nd != NULL);
+ IRO_ASSERT(4842, fnode != NULL);
+ IRO_ASSERT(4843, map != NULL);
+ IRO_ASSERT(4844, ptf != NULL);
memset(¶ms, 0, sizeof(params));
params.proc = proc;
@@ -3285,8 +3175,7 @@ static Boolean EvalAssign(Object *proc, IROLinear *nd, IRONode *fnode, ParamMapp
LocationSetSet_Init(params.srcs);
if (nd->type == IROLinearOp2Arg) {
-#line 4861
- IRO_ASSERT(nd->u.diadic.left->type == IROLinearOp1Arg && nd->u.diadic.left->nodetype == EINDIRECT);
+ IRO_ASSERT(4861, nd->u.diadic.left->type == IROLinearOp1Arg && nd->u.diadic.left->nodetype == EINDIRECT);
params.x15 |= EvalExpr(set, proc, nd->u.diadic.left->u.monadic, &stCallingContextStack, map, ptf);
AdjustTypesForVolatility(set, proc, nd->u.diadic.left);
@@ -3348,8 +3237,7 @@ static Boolean EvalAssign(Object *proc, IROLinear *nd, IRONode *fnode, ParamMapp
}
}
} else if (nd->type == IROLinearOp1Arg) {
-#line 4958
- IRO_ASSERT(nd->u.monadic.left->type == IROLinearOp1Arg && nd->u.monadic->nodetype == EINDIRECT);
+ IRO_ASSERT(4958, nd->u.monadic.left->type == IROLinearOp1Arg && nd->u.monadic->nodetype == EINDIRECT);
params.x15 |= EvalExpr(set, proc, nd->u.monadic->u.monadic, &stCallingContextStack, map, ptf);
AdjustTypesForVolatility(set, proc, nd->u.monadic);
@@ -3393,8 +3281,7 @@ static Boolean EvalAssign(Object *proc, IROLinear *nd, IRONode *fnode, ParamMapp
break;
}
} else {
-#line 5006
- CError_FATAL();
+ CError_FATAL(5006);
}
if (LocationSetSet_Count(params.srcs) != 0) {
@@ -3432,13 +3319,12 @@ static Boolean EvalReturn(Object *proc, IROLinear *nd, IRONode *fnode, ParamMapp
EvalAssignActionParams params;
LocationSet *loc;
-#line 5046
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(nd != NULL);
- IRO_ASSERT(nd->type == IROLinearReturn);
- IRO_ASSERT(fnode != NULL);
- IRO_ASSERT(map != NULL);
- IRO_ASSERT(ptf != NULL);
+ IRO_ASSERT(5046, proc != NULL);
+ IRO_ASSERT(5047, nd != NULL);
+ IRO_ASSERT(5048, nd->type == IROLinearReturn);
+ IRO_ASSERT(5049, fnode != NULL);
+ IRO_ASSERT(5050, map != NULL);
+ IRO_ASSERT(5051, ptf != NULL);
memset(¶ms, 0, sizeof(params));
params.proc = proc;
@@ -3496,33 +3382,29 @@ static void ApplySummaryAction2(ParamMapping *mapping, void *refcon) {
LocationSetSet *set;
EvalAssignActionParams assignParams;
-#line 5108
- IRO_ASSERT(mapping != NULL);
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(5108, mapping != NULL);
+ IRO_ASSERT(5109, refcon != NULL);
params = refcon;
-#line 5113
- IRO_ASSERT(params->tgtMap != NULL);
- IRO_ASSERT(params->proc != NULL);
- IRO_ASSERT(params->fnode != NULL);
- IRO_ASSERT(params->nd != NULL);
- IRO_ASSERT(params->nd->type == IROLinearFunccall);
- IRO_ASSERT(params->ptf != NULL);
- IRO_ASSERT(params->map != NULL);
- IRO_ASSERT(params->loc != NULL);
- IRO_ASSERT(params->locs != NULL);
+ IRO_ASSERT(5113, params->tgtMap != NULL);
+ IRO_ASSERT(5114, params->proc != NULL);
+ IRO_ASSERT(5115, params->fnode != NULL);
+ IRO_ASSERT(5116, params->nd != NULL);
+ IRO_ASSERT(5117, params->nd->type == IROLinearFunccall);
+ IRO_ASSERT(5118, params->ptf != NULL);
+ IRO_ASSERT(5119, params->map != NULL);
+ IRO_ASSERT(5120, params->loc != NULL);
+ IRO_ASSERT(5121, params->locs != NULL);
block = LocationSet_block(params->loc);
-#line 5124
- IRO_ASSERT(block != NULL);
- IRO_ASSERT(PAMemoryBlock_kind(block) == PAMEMORYBLOCKKIND_EXTENDEDPARAM);
+ IRO_ASSERT(5124, block != NULL);
+ IRO_ASSERT(5125, PAMemoryBlock_kind(block) == PAMEMORYBLOCKKIND_EXTENDEDPARAM);
ep = PAMemoryBlock_thing(block);
-#line 5127
- IRO_ASSERT(ep != NULL);
+ IRO_ASSERT(5127, ep != NULL);
if (ParamMapping_extended(mapping) == ep && (nd = ParamMapping_actual(mapping))) {
set = LocationSetSet_New();
@@ -3564,26 +3446,23 @@ static void ApplySummaryAction(PointsToEntry *pte, void *refcon) {
LocationSet *loc;
PAMemoryBlock *block;
-#line 5175
- IRO_ASSERT(pte != NULL);
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(5175, pte != NULL);
+ IRO_ASSERT(5176, refcon != NULL);
params = refcon;
-#line 5180
- IRO_ASSERT(params->tgtMap != NULL);
- IRO_ASSERT(params->proc != NULL);
- IRO_ASSERT(params->fnode != NULL);
- IRO_ASSERT(params->nd != NULL);
- IRO_ASSERT(params->nd->type == IROLinearFunccall);
- IRO_ASSERT(params->ptf != NULL);
- IRO_ASSERT(params->map != NULL);
+ IRO_ASSERT(5180, params->tgtMap != NULL);
+ IRO_ASSERT(5181, params->proc != NULL);
+ IRO_ASSERT(5182, params->fnode != NULL);
+ IRO_ASSERT(5183, params->nd != NULL);
+ IRO_ASSERT(5184, params->nd->type == IROLinearFunccall);
+ IRO_ASSERT(5185, params->ptf != NULL);
+ IRO_ASSERT(5186, params->map != NULL);
loc = PointsToEntry_loc(pte);
-#line 5189
- IRO_ASSERT(loc != NULL);
- IRO_ASSERT(!LocationSet_IsUnknown(loc));
+ IRO_ASSERT(5189, loc != NULL);
+ IRO_ASSERT(5190, !LocationSet_IsUnknown(loc));
block = LocationSet_block(loc);
if (block && PAMemoryBlock_kind(block) == PAMEMORYBLOCKKIND_EXTENDEDPARAM) {
@@ -3598,15 +3477,14 @@ static Boolean ApplySummary(PartialTransferFunction *tgtPTF, ParamMappingFunctio
ApplySummaryActionParams params;
PointsToFunction *pointsToFunc;
-#line 5208
- IRO_ASSERT(tgtPTF != NULL);
- IRO_ASSERT(tgtMap != NULL);
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(fnode != NULL);
- IRO_ASSERT(nd != NULL);
- IRO_ASSERT(nd->type == IROLinearFunccall);
- IRO_ASSERT(ptf != NULL);
- IRO_ASSERT(map != NULL);
+ IRO_ASSERT(5208, tgtPTF != NULL);
+ IRO_ASSERT(5209, tgtMap != NULL);
+ IRO_ASSERT(5210, proc != NULL);
+ IRO_ASSERT(5211, fnode != NULL);
+ IRO_ASSERT(5212, nd != NULL);
+ IRO_ASSERT(5213, nd->type == IROLinearFunccall);
+ IRO_ASSERT(5214, ptf != NULL);
+ IRO_ASSERT(5215, map != NULL);
StoreReturnedLocations(nd, tgtPTF, tgtMap);
if (tgtPTF == stUnknownPTF) {
@@ -3646,8 +3524,7 @@ static Boolean ApplySummary(PartialTransferFunction *tgtPTF, ParamMappingFunctio
}
static void GetPTFAction2(ParamMapping *mapping, void *refcon) {
-#line 5331
- IRO_ASSERT(mapping != NULL);
+ IRO_ASSERT(5331, mapping != NULL);
if (ParamMapping_extended(mapping))
ParamMapping_SetExtended(mapping, NULL);
@@ -3672,19 +3549,17 @@ typedef struct GetPTFActionParams {
static void GetPTFAction(PartialTransferFunction *tgtPTF, void *refcon) {
GetPTFActionParams *params;
-#line 5359
- IRO_ASSERT(tgtPTF != NULL);
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(5359, tgtPTF != NULL);
+ IRO_ASSERT(5360, refcon != NULL);
params = refcon;
-#line 5364
- IRO_ASSERT(params->map != NULL);
- IRO_ASSERT(params->proc != NULL);
- IRO_ASSERT(params->proc != &stUnknown);
- IRO_ASSERT(params->nd != NULL);
- IRO_ASSERT(params->ptf != NULL);
- IRO_ASSERT(params->needVisit != NULL);
+ IRO_ASSERT(5364, params->map != NULL);
+ IRO_ASSERT(5365, params->proc != NULL);
+ IRO_ASSERT(5366, params->proc != &stUnknown);
+ IRO_ASSERT(5367, params->nd != NULL);
+ IRO_ASSERT(5368, params->ptf != NULL);
+ IRO_ASSERT(5369, params->needVisit != NULL);
if (!params->x18) {
if (MatchPTF(tgtPTF, params->proc, params->map, params->nd, params->ptf)) {
@@ -3704,12 +3579,11 @@ static PartialTransferFunction *GetPTF(ParamMappingFunction *map, Object *proc,
PartialTransferFunction *result;
GetPTFActionParams params;
-#line 5396
- IRO_ASSERT(map != NULL);
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(nd != NULL);
- IRO_ASSERT(ptf != NULL);
- IRO_ASSERT(needVisit != NULL);
+ IRO_ASSERT(5396, map != NULL);
+ IRO_ASSERT(5397, proc != NULL);
+ IRO_ASSERT(5398, nd != NULL);
+ IRO_ASSERT(5399, ptf != NULL);
+ IRO_ASSERT(5400, needVisit != NULL);
if (proc == &stUnknown) {
result = stUnknownPTF;
@@ -3750,9 +3624,8 @@ static Boolean IsMeetNode(IRONode *fnode, IROLinear *nd) {
}
static Boolean IsExitNode(Object *proc, IRONode *fnode) {
-#line 5467
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(fnode != NULL);
+ IRO_ASSERT(5467, proc != NULL);
+ IRO_ASSERT(5468, fnode != NULL);
return (fnode->numsucc == 0) && Bv_IsBitSet(FunctionFirstNode(proc)->index, fnode->dom);
}
@@ -3760,9 +3633,8 @@ static Boolean IsExitNode(Object *proc, IRONode *fnode) {
static Boolean SomePredecessorHasBeenVisited(Object *proc, IRONode *fnode) {
UInt16 i;
-#line 5479
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(fnode != NULL);
+ IRO_ASSERT(5479, proc != NULL);
+ IRO_ASSERT(5480, fnode != NULL);
for (i = 0; i < fnode->numpred; i++) {
if (FunctionNodeTable(proc)[fnode->pred[i]]->x3C)
@@ -3775,8 +3647,8 @@ static Boolean SomePredecessorHasBeenVisited(Object *proc, IRONode *fnode) {
static Boolean AllPredecessorsHaveBeenVisited(Object *proc, IRONode *fnode) {
UInt16 i;
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(fnode != NULL);
+ IRO_ASSERT(0, proc != NULL);
+ IRO_ASSERT(0, fnode != NULL);
for (i = 0; i < fnode->numpred; i++) {
if (!FunctionNodeTable(proc)[fnode->pred[i]]->x3C)
@@ -3805,22 +3677,19 @@ static void EvalProcAction2(PointsToEntry *pte, void *refcon) {
LocationSetSet *set;
IRONode *node;
-#line 5525
- IRO_ASSERT(pte != NULL);
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(5525, pte != NULL);
+ IRO_ASSERT(5526, refcon != NULL);
params = refcon;
-#line 5530
- IRO_ASSERT(params->proc != NULL);
- IRO_ASSERT(params->fnode != NULL);
- IRO_ASSERT(params->ptf != NULL);
+ IRO_ASSERT(5530, params->proc != NULL);
+ IRO_ASSERT(5531, params->fnode != NULL);
+ IRO_ASSERT(5532, params->ptf != NULL);
dst = PointsToEntry_loc(pte);
-#line 5535
- IRO_ASSERT(dst != NULL);
- IRO_ASSERT(!LocationSet_IsUnknown(dst));
+ IRO_ASSERT(5535, dst != NULL);
+ IRO_ASSERT(5536, !LocationSet_IsUnknown(dst));
block = LocationSet_block(dst);
@@ -3862,17 +3731,15 @@ static void AssignEachInPointsToFunctionAction(PointsToEntry *pte, void *refcon)
LocationSet *dst;
LocationSetSet *srcs;
-#line 5577
- IRO_ASSERT(pte != NULL);
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(5577, pte != NULL);
+ IRO_ASSERT(5578, refcon != NULL);
params = refcon;
-#line 5582
- IRO_ASSERT(params->proc != NULL);
- IRO_ASSERT(params->nd != NULL);
- IRO_ASSERT(params->fnode != NULL);
- IRO_ASSERT(params->ptf != NULL);
+ IRO_ASSERT(5582, params->proc != NULL);
+ IRO_ASSERT(5583, params->nd != NULL);
+ IRO_ASSERT(5584, params->fnode != NULL);
+ IRO_ASSERT(5585, params->ptf != NULL);
dst = PointsToEntry_loc(pte);
@@ -3888,14 +3755,12 @@ static void AssignEachInPointsToFunction(PointsToFunction *pointsTo, void *refco
AssignEachInPointsToFunctionActionParams *params;
PointsToFunction *pointsToFunc;
-#line 5602
- IRO_ASSERT(pointsTo != NULL);
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(5602, pointsTo != NULL);
+ IRO_ASSERT(5603, refcon != NULL);
params = refcon;
-#line 5607
- IRO_ASSERT(params->nd != NULL);
+ IRO_ASSERT(5607, params->nd != NULL);
pointsToFunc = PointsToFunction_New();
if (params->nd->pointsToFunction)
@@ -3929,10 +3794,9 @@ static void AssignEachInPointsToFunction(PointsToFunction *pointsTo, void *refco
static Boolean ObjectIsAFunctionArgument(Object *proc, Object *obj) {
ObjectList *list;
-#line 5643
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(proc != &stUnknown);
- IRO_ASSERT(obj != NULL);
+ IRO_ASSERT(5643, proc != NULL);
+ IRO_ASSERT(5644, proc != &stUnknown);
+ IRO_ASSERT(5645, obj != NULL);
if (obj->datatype == DLOCAL) {
for (list = FunctionArguments(proc); list; list = list->next) {
@@ -3947,10 +3811,9 @@ static Boolean ObjectIsAFunctionArgument(Object *proc, Object *obj) {
static Boolean ObjectIsARealFunctionArgument(Object *proc, Object *obj) {
ObjectList *list;
-#line 5661
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(proc != &stUnknown);
- IRO_ASSERT(obj != NULL);
+ IRO_ASSERT(5661, proc != NULL);
+ IRO_ASSERT(5662, proc != &stUnknown);
+ IRO_ASSERT(5663, obj != NULL);
if (obj->datatype == DLOCAL && proc == cscope_currentfunc) {
for (list = arguments; list; list = list->next) {
@@ -3963,10 +3826,9 @@ static Boolean ObjectIsARealFunctionArgument(Object *proc, Object *obj) {
}
static void AddLocalVarsAddressedByExceptionUses(Object *var) {
-#line 5699
- IRO_ASSERT(var != NULL);
- IRO_ASSERT(stExceptionFNode != NULL);
- IRO_ASSERT(stExceptionFNode->addressed != NULL);
+ IRO_ASSERT(5699, var != NULL);
+ IRO_ASSERT(5700, stExceptionFNode != NULL);
+ IRO_ASSERT(5701, stExceptionFNode->addressed != NULL);
if (var->datatype == DLOCAL)
ObjectSet_sub_4867D0(stExceptionFNode->addressed, var);
@@ -4020,9 +3882,8 @@ static void EvalProcAction(IROLinear *Int, Boolean flag) {
static int userBreakCounter;
if (!flag && !Int->x1E) {
-#line 5748
- IRO_ASSERT(Int != NULL);
- IRO_ASSERT(stEvalProcActionParams.changed != NULL);
+ IRO_ASSERT(5748, Int != NULL);
+ IRO_ASSERT(5749, stEvalProcActionParams.changed != NULL);
proc = stEvalProcActionParams.proc;
fnode = stEvalProcActionParams.fnode;
@@ -4033,11 +3894,10 @@ static void EvalProcAction(IROLinear *Int, Boolean flag) {
x18 = stEvalProcActionParams.x18;
x19 = stEvalProcActionParams.x19;
-#line 5760
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(fnode != NULL);
- IRO_ASSERT(map != NULL);
- IRO_ASSERT(ptf != NULL);
+ IRO_ASSERT(5760, proc != NULL);
+ IRO_ASSERT(5761, fnode != NULL);
+ IRO_ASSERT(5762, map != NULL);
+ IRO_ASSERT(5763, ptf != NULL);
if (++userBreakCounter > 40) {
IRO_CheckForUserBreak();
@@ -4145,10 +4005,9 @@ static void EvalProc(Object *proc, ParamMappingFunction *map, PartialTransferFun
AssignEachInPointsToFunctionActionParams assignParams;
EvalProcActionParams params;
-#line 5964
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(map != NULL);
- IRO_ASSERT(ptf != NULL);
+ IRO_ASSERT(5964, proc != NULL);
+ IRO_ASSERT(5965, map != NULL);
+ IRO_ASSERT(5966, ptf != NULL);
for (fnode = FunctionFirstNode(proc); fnode; fnode = fnode->nextnode)
fnode->x3C = 0;
@@ -4213,10 +4072,8 @@ static void EvalProc(Object *proc, ParamMappingFunction *map, PartialTransferFun
}
clock();
- if (++passCount > 32) {
-#line 6072
- CError_FATAL();
- }
+ if (++passCount > 32)
+ CError_FATAL(6072);
} while (changed);
if (passCount > stMaxPassCount)
@@ -4253,9 +4110,8 @@ static void CleanseLocationSet(LocationSet *loc, void *refcon) {
PAMemoryBlock *block;
PALocalVar *local;
-#line 6161
- IRO_ASSERT(loc != NULL);
- IRO_ASSERT(refcon == NULL);
+ IRO_ASSERT(6161, loc != NULL);
+ IRO_ASSERT(6162, refcon == NULL);
if (
!LocationSet_IsUnknown(loc) &&
@@ -4268,18 +4124,16 @@ static void CleanseLocationSet(LocationSet *loc, void *refcon) {
}
static void CleansePointsToEntry(PointsToEntry *pte, void *refcon) {
-#line 6177
- IRO_ASSERT(pte != NULL);
- IRO_ASSERT(refcon == NULL);
+ IRO_ASSERT(6177, pte != NULL);
+ IRO_ASSERT(6178, refcon == NULL);
CleanseLocationSet(PointsToEntry_loc(pte), NULL);
LocationSetSet_ForEach(PointsToEntry_locs(pte), CleanseLocationSet, NULL);
}
static void PointerAnalysis_TermAction4(PartialTransferFunction *ptf, void *refcon) {
-#line 6187
- IRO_ASSERT(ptf != NULL);
- IRO_ASSERT(refcon == NULL);
+ IRO_ASSERT(6187, ptf != NULL);
+ IRO_ASSERT(6188, refcon == NULL);
if (ptf != stUnknownPTF) {
PointsToFunction_ForEach(PartialTransferFunction_initialPointsToFn(ptf), CleansePointsToEntry, NULL);
@@ -4369,8 +4223,7 @@ static void InvalidatePointsToFunctions(Object *proc) {
IRONode *fnode;
IROLinear *nd;
-#line 6302
- IRO_ASSERT(proc != NULL);
+ IRO_ASSERT(6302, proc != NULL);
for (fnode = FunctionFirstNode(proc); fnode; fnode = fnode->nextnode) {
if (fnode->last) {
@@ -4425,8 +4278,7 @@ void IRO_AnalyzePointers(Object *function) {
int code;
volatile heaperror_t saveheaperror;
-#line 6393
- IRO_ASSERT(function != NULL);
+ IRO_ASSERT(6393, function != NULL);
PointerAnalysis_Init();
@@ -4724,10 +4576,9 @@ static void GetDefiniteObjectOfExtendedParamLoc(LocationSet *loc, Object **resul
LocationSet *tmp;
PALocalVar *local;
-#line 6763
- IRO_ASSERT(loc != NULL);
- IRO_ASSERT(resultObj != NULL);
- IRO_ASSERT(resultField != NULL);
+ IRO_ASSERT(6763, loc != NULL);
+ IRO_ASSERT(6764, resultObj != NULL);
+ IRO_ASSERT(6765, resultField != NULL);
obj = NULL;
field = LocationSet_field(loc);
@@ -4735,8 +4586,7 @@ static void GetDefiniteObjectOfExtendedParamLoc(LocationSet *loc, Object **resul
if (block && PAMemoryBlock_kind(block) == PAMEMORYBLOCKKIND_EXTENDEDPARAM) {
if ((ep = PAMemoryBlock_thing(block)) && (objSet = ExtendedParam_objectSet(ep))) {
-#line 6777
- IRO_ASSERT(obj == NULL);
+ IRO_ASSERT(6777, obj == NULL);
ObjectSet_ForEach(objSet, FindGlobalObjectAction, &obj);
}
}
@@ -4759,8 +4609,7 @@ static void GetDefiniteObjectOfExtendedParamLoc(LocationSet *loc, Object **resul
(objSet = ExtendedParam_objectSet(ep))
)
{
-#line 6801
- IRO_ASSERT(obj == NULL);
+ IRO_ASSERT(6801, obj == NULL);
ObjectSet_ForEach(objSet, FindGlobalObjectAction, &obj);
} else if (
(block = LocationSet_block(tmp)) &&
@@ -4788,13 +4637,12 @@ static void CreateExpressionForLocationSet(LocationSet *loc, IROList *list, Type
IROLinear *nd;
Object *obj;
-#line 6833
- IRO_ASSERT(loc != NULL);
- IRO_ASSERT(!LocationSet_IsUnknown(loc));
- IRO_ASSERT(LocationSet_stride(loc) == 0);
- IRO_ASSERT(list != NULL);
- IRO_ASSERT(rtype != NULL);
- IRO_ASSERT(proc != NULL);
+ IRO_ASSERT(6833, loc != NULL);
+ IRO_ASSERT(6834, !LocationSet_IsUnknown(loc));
+ IRO_ASSERT(6835, LocationSet_stride(loc) == 0);
+ IRO_ASSERT(6836, list != NULL);
+ IRO_ASSERT(6837, rtype != NULL);
+ IRO_ASSERT(6838, proc != NULL);
field = LocationSet_field(loc);
block = LocationSet_block(loc);
@@ -4834,8 +4682,7 @@ static void CreateExpressionForLocationSet(LocationSet *loc, IROList *list, Type
case PAMEMORYBLOCKKIND_6:
break;
default:
-#line 6894
- CError_FATAL();
+ CError_FATAL(6894);
}
if (nd && !CInt64_IsZero(&field)) {
@@ -4871,16 +4718,14 @@ static void LookupLinearExprAction(LocationSet *loc, void *refcon) {
LookupLinearExprActionParams *params;
IROListNode *list;
-#line 6926
- IRO_ASSERT(loc != NULL);
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(6926, loc != NULL);
+ IRO_ASSERT(6927, refcon != NULL);
params = refcon;
-#line 6931
- IRO_ASSERT(params->proc != NULL);
- IRO_ASSERT(params->indirectType != NULL);
- IRO_ASSERT(params->list != NULL);
+ IRO_ASSERT(6931, params->proc != NULL);
+ IRO_ASSERT(6932, params->indirectType != NULL);
+ IRO_ASSERT(6933, params->list != NULL);
list = *params->list = IRO_malloc(sizeof(IROListNode));
IRO_InitList(&list->list);
@@ -4896,8 +4741,7 @@ void PointerAnalysis_LookupLinearNodePointerExpr(Object *proc, IROLinear *indire
LocationSetSet *set;
LookupLinearExprActionParams params;
-#line 6957
- IRO_ASSERT(indirect != NULL);
+ IRO_ASSERT(6957, indirect != NULL);
if (indirect->pointsToFunction) {
set = LocationSetSet_New();
@@ -4923,12 +4767,12 @@ static void CreateENodeForLocationSet(LocationSet *loc, ENode **resultNode, Type
ENode *nd;
Object *obj;
- IRO_ASSERT(loc != NULL);
- IRO_ASSERT(!LocationSet_IsUnknown(loc));
- IRO_ASSERT(LocationSet_stride(loc) == 0);
- IRO_ASSERT(resultNode != NULL);
- IRO_ASSERT(rtype != NULL);
- IRO_ASSERT(proc != NULL);
+ IRO_ASSERT(0, loc != NULL);
+ IRO_ASSERT(0, !LocationSet_IsUnknown(loc));
+ IRO_ASSERT(0, LocationSet_stride(loc) == 0);
+ IRO_ASSERT(0, resultNode != NULL);
+ IRO_ASSERT(0, rtype != NULL);
+ IRO_ASSERT(0, proc != NULL);
field = LocationSet_field(loc);
block = LocationSet_block(loc);
@@ -4963,8 +4807,7 @@ static void CreateENodeForLocationSet(LocationSet *loc, ENode **resultNode, Type
case PAMEMORYBLOCKKIND_6:
break;
default:
-#line 7040
- CError_FATAL();
+ CError_FATAL(7040);
}
if (nd && !CInt64_IsZero(&field)) {
@@ -5002,14 +4845,14 @@ static void LookupENodeExprAction(LocationSet *loc, void *refcon) {
LookupENodeExprActionParams *params;
ENodeList *list;
- IRO_ASSERT(loc != NULL);
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(0, loc != NULL);
+ IRO_ASSERT(0, refcon != NULL);
params = refcon;
- IRO_ASSERT(params->proc != NULL);
- IRO_ASSERT(params->indirectType != NULL);
- IRO_ASSERT(params->list != NULL);
+ IRO_ASSERT(0, params->proc != NULL);
+ IRO_ASSERT(0, params->indirectType != NULL);
+ IRO_ASSERT(0, params->list != NULL);
list = *params->list = IRO_malloc(sizeof(ENodeList));
list->node = NULL;
@@ -5025,7 +4868,7 @@ void PointerAnalysis_LookupENodePointerExpr(Object *proc, ENode *indirect, ENode
LocationSetSet *set;
LookupENodeExprActionParams params;
- IRO_ASSERT(indirect != NULL);
+ IRO_ASSERT(0, indirect != NULL);
if (indirect->pointsTo) {
set = LocationSetSet_New();
@@ -5043,7 +4886,7 @@ void PointerAnalysis_LookupENodePointerExpr(Object *proc, ENode *indirect, ENode
}
}
-void PointerAnalysis_LookupVariableIntoLinearNodeExprs(Object *proc, VarRecord *var, PointsToFunction *pointsTo, IROList **list) {
+void PointerAnalysis_LookupVariableIntoLinearNodeExprs(Object *proc, VarRecord *var, PointsToFunction *pointsTo, IROListNode **list) {
LocationSetSet *set;
LookupLinearExprActionParams params;
@@ -5106,18 +4949,16 @@ static void GetFunctionDepsOrKillsAction(LocationSet *ls, void *refcon) {
PALocalVar *local;
Object *obj;
-#line 7204
- IRO_ASSERT(ls != NULL);
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(7204, ls != NULL);
+ IRO_ASSERT(7205, refcon != NULL);
params = refcon;
-#line 7209
- IRO_ASSERT(params->proc != NULL);
- IRO_ASSERT(params->ptf != NULL);
- IRO_ASSERT(params->funccall != NULL);
- IRO_ASSERT(params->map == NULL || params->map != NULL);
- IRO_ASSERT(params->list != NULL);
+ IRO_ASSERT(7209, params->proc != NULL);
+ IRO_ASSERT(7210, params->ptf != NULL);
+ IRO_ASSERT(7211, params->funccall != NULL);
+ IRO_ASSERT(7212, params->map == NULL || params->map != NULL);
+ IRO_ASSERT(7213, params->list != NULL);
list = *params->list = IRO_malloc(sizeof(ObjectList));
list->object = NULL;
@@ -5128,8 +4969,7 @@ static void GetFunctionDepsOrKillsAction(LocationSet *ls, void *refcon) {
switch (PAMemoryBlock_kind(block)) {
case PAMEMORYBLOCKKIND_EXTENDEDPARAM:
if ((ep = PAMemoryBlock_thing(block)) && (objSet = ExtendedParam_objectSet(ep))) {
-#line 7232
- IRO_ASSERT(obj == NULL);
+ IRO_ASSERT(7232, obj == NULL);
ObjectSet_ForEach(objSet, FindGlobalObjectAction, &obj);
}
break;
@@ -5154,23 +4994,20 @@ static void GetFunctionDepsOrKillsAction2(PointsToEntry *pte, void *refcon) {
PAMemoryBlock *block;
LocationSetSet *set;
-#line 7264
- IRO_ASSERT(pte != NULL);
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(7264, pte != NULL);
+ IRO_ASSERT(7265, refcon != NULL);
params = refcon;
-#line 7269
- IRO_ASSERT(params->proc != NULL);
- IRO_ASSERT(params->ptf != NULL);
- IRO_ASSERT(params->funccall != NULL);
- IRO_ASSERT(params->map != NULL);
- IRO_ASSERT(params->list != NULL);
+ IRO_ASSERT(7269, params->proc != NULL);
+ IRO_ASSERT(7270, params->ptf != NULL);
+ IRO_ASSERT(7271, params->funccall != NULL);
+ IRO_ASSERT(7272, params->map != NULL);
+ IRO_ASSERT(7273, params->list != NULL);
loc = PointsToEntry_loc(pte);
-#line 7277
- IRO_ASSERT(!LocationSet_IsUnknown(loc));
+ IRO_ASSERT(7277, !LocationSet_IsUnknown(loc));
if ((block = LocationSet_block(loc)) && PAMemoryBlock_kind(block) == PAMEMORYBLOCKKIND_EXTENDEDPARAM) {
set = LocationSetSet_New();
@@ -5258,10 +5095,9 @@ void PointerAnalysis_GetFunctionKills(Object *proc, IROLinear *funccall, ObjectL
LocationSetSet *set;
GetFunctionDepsOrKillsActionParams params;
-#line 7398
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(funccall != NULL);
- IRO_ASSERT(funccall->type == IROLinearFunccall);
+ IRO_ASSERT(7398, proc != NULL);
+ IRO_ASSERT(7399, funccall != NULL);
+ IRO_ASSERT(7400, funccall->type == IROLinearFunccall);
if (!ObjectIsAFunction(proc))
return;
@@ -5294,10 +5130,9 @@ void PointerAnalysis_GetFunctionDependencies(Object *proc, IROLinear *funccall,
PointsToFunction *finalPointsTo;
GetFunctionDepsOrKillsActionParams params;
-#line 7446
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(funccall != NULL);
- IRO_ASSERT(funccall->type == IROLinearFunccall);
+ IRO_ASSERT(7446, proc != NULL);
+ IRO_ASSERT(7447, funccall != NULL);
+ IRO_ASSERT(7448, funccall->type == IROLinearFunccall);
if (!ObjectIsAFunction(proc))
return;
@@ -5373,15 +5208,14 @@ static void ParseLocationSet(LocationSet *loc, Type *rtype, Object *proc, Create
Boolean anotherFlag;
Boolean isUnknown;
-#line 7552
- IRO_ASSERT(loc != NULL);
- IRO_ASSERT(rtype == NULL || rtype != NULL);
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(createNewParamObjects == CREATE_NEW_PARAM_OBJECTS_FALSE || createNewParamObjects == CREATE_NEW_PARAM_OBJECTS_TRUE);
- IRO_ASSERT(resultFailed != NULL);
- IRO_ASSERT(*resultFailed == false);
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(proc == NULL || ObjectIsAFunction(proc));
+ IRO_ASSERT(7552, loc != NULL);
+ IRO_ASSERT(7553, rtype == NULL || rtype != NULL);
+ IRO_ASSERT(7554, proc != NULL);
+ IRO_ASSERT(7555, createNewParamObjects == CREATE_NEW_PARAM_OBJECTS_FALSE || createNewParamObjects == CREATE_NEW_PARAM_OBJECTS_TRUE);
+ IRO_ASSERT(7556, resultFailed != NULL);
+ IRO_ASSERT(7557, *resultFailed == false);
+ IRO_ASSERT(7558, proc != NULL);
+ IRO_ASSERT(7559, proc == NULL || ObjectIsAFunction(proc));
failed = 0;
isUnknown = 0;
@@ -5484,8 +5318,7 @@ static void ParseLocationSet(LocationSet *loc, Type *rtype, Object *proc, Create
}
} else {
ep = obj->extParam;
-#line 7687
- IRO_ASSERT(ep != NULL);
+ IRO_ASSERT(7687, ep != NULL);
}
if (!failed) {
@@ -5625,15 +5458,14 @@ static void ParseLocationSet(LocationSet *loc, Type *rtype, Object *proc, Create
static void ParseLocationSetSet(LocationSetSet *locs, Type *rtype, Object *proc, CreateNewParamObjects createNewParamObjects, Boolean *resultFailed) {
Boolean failed;
-#line 7892
- IRO_ASSERT(locs != NULL);
- IRO_ASSERT(rtype == NULL || rtype != NULL);
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(createNewParamObjects == CREATE_NEW_PARAM_OBJECTS_FALSE || createNewParamObjects == CREATE_NEW_PARAM_OBJECTS_TRUE);
- IRO_ASSERT(resultFailed != NULL);
- IRO_ASSERT(*resultFailed == false);
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(proc == NULL || ObjectIsAFunction(proc));
+ IRO_ASSERT(7892, locs != NULL);
+ IRO_ASSERT(7893, rtype == NULL || rtype != NULL);
+ IRO_ASSERT(7894, proc != NULL);
+ IRO_ASSERT(7895, createNewParamObjects == CREATE_NEW_PARAM_OBJECTS_FALSE || createNewParamObjects == CREATE_NEW_PARAM_OBJECTS_TRUE);
+ IRO_ASSERT(7896, resultFailed != NULL);
+ IRO_ASSERT(7897, *resultFailed == false);
+ IRO_ASSERT(7898, proc != NULL);
+ IRO_ASSERT(7899, proc == NULL || ObjectIsAFunction(proc));
failed = 0;
@@ -5682,14 +5514,13 @@ static void ParseLocationSetSet(LocationSetSet *locs, Type *rtype, Object *proc,
static Object *GetFunctionObjectFromDeclInfo(DeclInfo *di) {
Object *proc;
-#line 7953
- IRO_ASSERT(di != NULL);
+ IRO_ASSERT(7953, di != NULL);
if (di->storageclass != TK_TYPEDEF && IS_TYPE_FUNC(di->thetype)) {
Boolean flag;
proc = CDecl_GetFunctionObject(di, NULL, &flag, 1);
if (flag)
- di->fileoffsetinfo.is_inline = 1;
+ di->x64 = 1;
} else {
proc = NULL;
}
@@ -5702,17 +5533,14 @@ void PointerAnalysis_ParseEntryPointsToSpecifier(DeclInfo *di) {
Boolean failed;
Boolean anotherFlag;
-#line 7982
- IRO_ASSERT(di != NULL);
+ IRO_ASSERT(7982, di != NULL);
proc = GetFunctionObjectFromDeclInfo(di);
if (proc) {
-#line 7987
- IRO_ASSERT(proc == NULL || ObjectIsAFunction(proc));
+ IRO_ASSERT(7987, proc == NULL || ObjectIsAFunction(proc));
tk = lex();
-#line 7996
- IRO_ASSERT(tk == TK_IDENTIFIER && strcmp(tkidentifier->name,"entry_points_to") == 0);
+ IRO_ASSERT(7996, tk == TK_IDENTIFIER && strcmp(tkidentifier->name,"entry_points_to") == 0);
failed = 0;
@@ -5787,17 +5615,14 @@ void PointerAnalysis_ParseExitPointsToSpecifier(DeclInfo *di) {
Boolean failed;
Boolean anotherFlag;
-#line 8097
- IRO_ASSERT(di != NULL);
+ IRO_ASSERT(8097, di != NULL);
proc = GetFunctionObjectFromDeclInfo(di);
if (proc) {
-#line 8102
- IRO_ASSERT(proc == NULL || ObjectIsAFunction(proc));
+ IRO_ASSERT(8102, proc == NULL || ObjectIsAFunction(proc));
tk = lex();
-#line 8111
- IRO_ASSERT(tk == TK_IDENTIFIER && strcmp(tkidentifier->name,"exit_points_to") == 0);
+ IRO_ASSERT(8111, tk == TK_IDENTIFIER && strcmp(tkidentifier->name,"exit_points_to") == 0);
failed = 0;
@@ -5877,17 +5702,14 @@ void PointerAnalysis_ParseFunctionModifiesSpecifier(DeclInfo *di) {
PartialTransferFunction *ptf;
LocationSetSet *ptfLSS;
-#line 8211
- IRO_ASSERT(di != NULL);
+ IRO_ASSERT(8211, di != NULL);
proc = GetFunctionObjectFromDeclInfo(di);
if (proc) {
-#line 8216
- IRO_ASSERT(proc == NULL || ObjectIsAFunction(proc));
+ IRO_ASSERT(8216, proc == NULL || ObjectIsAFunction(proc));
tk = lex();
-#line 8225
- IRO_ASSERT(tk == TK_IDENTIFIER && strcmp(tkidentifier->name,"function_modifies") == 0);
+ IRO_ASSERT(8225, tk == TK_IDENTIFIER && strcmp(tkidentifier->name,"function_modifies") == 0);
failed = 0;
lss = LocationSetSet_New();
diff --git a/compiler_and_linker/unsorted/IroPointerAnalysisADTs.c b/compiler_and_linker/unsorted/IroPointerAnalysisADTs.c
index baec435..cf54aca 100644
--- a/compiler_and_linker/unsorted/IroPointerAnalysisADTs.c
+++ b/compiler_and_linker/unsorted/IroPointerAnalysisADTs.c
@@ -43,17 +43,17 @@ typedef UInt32 uint32;
void __assertion_failed(char *expr, char *filename, int line);
#ifdef IRO_DEBUG
-#define IRO_ASSERT(expr) \
+#define IRO_ASSERT(line, expr) \
do { \
if (!(expr)) { \
- __assertion_failed(#expr, __FILE__, __LINE__); \
+ __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_ASSERT(line, expr) ((void) 0)
#define IRO_DEBUG_CLEAR(obj, type) ((void) 0)
#endif
@@ -222,8 +222,7 @@ inline void PTFList_RemoveAll(PTFList *ptfList);
inline StackElement *StackElement_New(void) {
StackElement *stackElement = IRO_malloc(sizeof(StackElement));
-#line 103
- IRO_ASSERT(stackElement != NULL);
+ IRO_ASSERT(103, stackElement != NULL);
#ifdef IRO_DEBUG
stackElement->proc = NULL;
stackElement->ptf = NULL;
@@ -234,23 +233,21 @@ inline StackElement *StackElement_New(void) {
}
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_ASSERT(117, stackElement != NULL);
+ IRO_ASSERT(118, stackElement->proc == NULL);
+ IRO_ASSERT(119, stackElement->ptf == NULL);
+ IRO_ASSERT(120, stackElement->map == NULL);
+ IRO_ASSERT(121, 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);
+ IRO_ASSERT(131, stackElement != NULL);
+ IRO_ASSERT(132, proc != NULL);
+ IRO_ASSERT(133, ptf != NULL);
+ IRO_ASSERT(134, map != NULL);
+ IRO_ASSERT(135, funcCall != NULL);
stackElement->proc = proc;
stackElement->ptf = ptf;
stackElement->map = map;
@@ -258,15 +255,13 @@ inline void StackElement_Init(StackElement *stackElement, Object *proc, PartialT
}
inline void StackElement_Copy(StackElement *dest, StackElement *src) {
-#line 145
- IRO_ASSERT(dest != NULL);
- IRO_ASSERT(src != NULL);
+ IRO_ASSERT(145, dest != NULL);
+ IRO_ASSERT(146, 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);
+ IRO_ASSERT(156, stackElement != NULL);
#ifdef IRO_DEBUG
stackElement->proc = NULL;
stackElement->ptf = NULL;
@@ -276,46 +271,39 @@ inline void StackElement_Term(StackElement *stackElement) {
}
inline void *StackElement_sub_48A780(StackElement *stackElement) {
-#line 213
- IRO_ASSERT(stackElement != NULL);
+ IRO_ASSERT(213, stackElement != NULL);
return stackElement->proc;
}
inline Boolean StackRelated_sub_48A760(void *key1, void *key2) {
-#line 220
- IRO_ASSERT(key1 != NULL);
- IRO_ASSERT(key2 != NULL);
+ IRO_ASSERT(220, key1 != NULL);
+ IRO_ASSERT(221, key2 != NULL);
return key1 == key2;
}
inline Object *StackElement_proc(StackElement *stackElement) {
-#line 228
- IRO_ASSERT(stackElement != NULL);
+ IRO_ASSERT(228, stackElement != NULL);
return stackElement->proc;
}
inline PartialTransferFunction *StackElement_ptf(StackElement *stackElement) {
-#line 235
- IRO_ASSERT(stackElement != NULL);
+ IRO_ASSERT(235, stackElement != NULL);
return stackElement->ptf;
}
inline ParamMappingFunction *StackElement_map(StackElement *stackElement) {
-#line 242
- IRO_ASSERT(stackElement != NULL);
+ IRO_ASSERT(242, stackElement != NULL);
return stackElement->map;
}
inline IROLinear *StackElement_funcCall(StackElement *stackElement) {
-#line 249
- IRO_ASSERT(stackElement != NULL);
+ IRO_ASSERT(249, stackElement != NULL);
return stackElement->funcCall;
}
inline Stack *Stack_New(void) {
Stack *stack = IRO_malloc(sizeof(Stack));
-#line 265
- IRO_ASSERT(stack != NULL);
+ IRO_ASSERT(265, stack != NULL);
#ifdef IRO_DEBUG
stack->top = NULL;
stack->next = NULL;
@@ -324,17 +312,15 @@ inline Stack *Stack_New(void) {
}
inline void Stack_Delete(Stack *stack) {
-#line 277
- IRO_ASSERT(stack != NULL);
- IRO_ASSERT(stack->top == NULL);
- IRO_ASSERT(stack->next == NULL);
+ IRO_ASSERT(277, stack != NULL);
+ IRO_ASSERT(278, stack->top == NULL);
+ IRO_ASSERT(279, stack->next == NULL);
IRO_DEBUG_CLEAR(stack, sizeof(Stack));
IRO_free(stack);
}
inline void Stack_Init(Stack *stack) {
-#line 289
- IRO_ASSERT(stack != NULL);
+ IRO_ASSERT(289, stack != NULL);
stack->top = NULL;
stack->next = NULL;
}
@@ -342,9 +328,8 @@ inline void Stack_Init(Stack *stack) {
inline void Stack_Term(Stack **stackPtr) {
StackElement *stackElement;
-#line 299
- IRO_ASSERT(stackPtr != NULL);
- IRO_ASSERT(*stackPtr != NULL);
+ IRO_ASSERT(299, stackPtr != NULL);
+ IRO_ASSERT(300, *stackPtr != NULL);
while ((*stackPtr)->top) {
stackElement = Stack_sub_48A5B0(stackPtr);
@@ -357,9 +342,8 @@ inline void Stack_sub_48A660(Stack **stackPtr, StackElement *stackElement) {
StackElement *newElement;
Stack *newStack;
-#line 315
- IRO_ASSERT(stackPtr != NULL);
- IRO_ASSERT(*stackPtr != NULL);
+ IRO_ASSERT(315, stackPtr != NULL);
+ IRO_ASSERT(316, *stackPtr != NULL);
newElement = StackElement_New();
StackElement_Copy(newElement, stackElement);
@@ -371,17 +355,15 @@ inline void Stack_sub_48A660(Stack **stackPtr, StackElement *stackElement) {
}
inline StackElement *Stack_Top(Stack **stackPtr) {
-#line 331
- IRO_ASSERT(stackPtr != NULL);
- IRO_ASSERT(*stackPtr != NULL);
+ IRO_ASSERT(331, stackPtr != NULL);
+ IRO_ASSERT(332, *stackPtr != NULL);
return (*stackPtr)->top;
}
inline Stack *Stack_Next(Stack **stackPtr) {
-#line 343
- IRO_ASSERT(stackPtr != NULL);
- IRO_ASSERT(*stackPtr != NULL);
+ IRO_ASSERT(343, stackPtr != NULL);
+ IRO_ASSERT(344, *stackPtr != NULL);
return (*stackPtr)->next;
}
@@ -389,9 +371,8 @@ inline Stack *Stack_Next(Stack **stackPtr) {
inline StackElement *Stack_sub_48A5B0(Stack **stackPtr) {
StackElement *stackElement;
-#line 357
- IRO_ASSERT(stackPtr != NULL);
- IRO_ASSERT(*stackPtr != NULL);
+ IRO_ASSERT(357, stackPtr != NULL);
+ IRO_ASSERT(358, *stackPtr != NULL);
stackElement = (*stackPtr)->top;
if (stackElement) {
@@ -408,9 +389,8 @@ inline StackElement *Stack_sub_48A5B0(Stack **stackPtr) {
inline StackElement *Stack_sub_48A710(Stack **stackPtr, void *key) {
Stack *stack;
-#line 379
- IRO_ASSERT(stackPtr != NULL);
- IRO_ASSERT(key != NULL);
+ IRO_ASSERT(379, stackPtr != NULL);
+ IRO_ASSERT(380, key != NULL);
for (stack = *stackPtr; stack; stack = stack->next) {
if (stack->top) {
@@ -426,8 +406,7 @@ inline ObjectSet *ObjectSet_New(void) {
ObjectSet *procList;
procList = IRO_malloc(sizeof(ObjectSet));
-#line 439
- IRO_ASSERT(procList != NULL);
+ IRO_ASSERT(439, procList != NULL);
#ifdef IRO_DEBUG
procList->proc = NULL;
procList->otherProcs = NULL;
@@ -436,24 +415,21 @@ inline ObjectSet *ObjectSet_New(void) {
}
inline void ObjectSet_Delete(ObjectSet *procList) {
-#line 451
- IRO_ASSERT(procList != NULL);
- IRO_ASSERT(procList->proc == NULL);
- IRO_ASSERT(procList->otherProcs == NULL);
+ IRO_ASSERT(451, procList != NULL);
+ IRO_ASSERT(452, procList->proc == NULL);
+ IRO_ASSERT(453, procList->otherProcs == NULL);
IRO_DEBUG_CLEAR(procList, sizeof(ObjectSet));
IRO_free(procList);
}
inline void ObjectSet_Init(ObjectSet *procList) {
-#line 463
- IRO_ASSERT(procList != NULL);
+ IRO_ASSERT(463, procList != NULL);
procList->proc = NULL;
procList->otherProcs = NULL;
}
inline void ObjectSet_Term(ObjectSet *procList) {
-#line 481
- IRO_ASSERT(procList != NULL);
+ IRO_ASSERT(481, procList != NULL);
ObjectSet_RemoveAll(procList);
#ifdef IRO_DEBUG
procList->proc = NULL;
@@ -462,10 +438,9 @@ inline void ObjectSet_Term(ObjectSet *procList) {
}
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);
+ IRO_ASSERT(528, procList != NULL);
+ IRO_ASSERT(529, action != NULL);
+ IRO_ASSERT(530, refcon == NULL || refcon != NULL);
while (procList && procList->proc) {
action(procList->proc, refcon);
@@ -474,9 +449,8 @@ inline void ObjectSet_ForEach(ObjectSet *procList, void (*action)(Object *, void
}
inline Object *ObjectSet_sub_485020(ObjectSet *procList, Object *proc) {
-#line 540
- IRO_ASSERT(procList != NULL);
- IRO_ASSERT(proc != NULL);
+ IRO_ASSERT(540, procList != NULL);
+ IRO_ASSERT(541, proc != NULL);
while (procList && procList->proc) {
if (procList->proc == proc)
return procList->proc;
@@ -486,16 +460,14 @@ inline Object *ObjectSet_sub_485020(ObjectSet *procList, Object *proc) {
}
inline Object *ObjectSet_FindFirst(ObjectSet *procList) {
-#line 552
- IRO_ASSERT(procList != NULL);
+ IRO_ASSERT(552, procList != NULL);
return procList->proc;
}
inline int ObjectSet_Count(ObjectSet *procList) {
int count;
-#line 552
- IRO_ASSERT(procList != NULL);
+ IRO_ASSERT(561, procList != NULL);
count = 0;
while (procList && procList->proc) {
@@ -509,9 +481,8 @@ inline int ObjectSet_Count(ObjectSet *procList) {
inline void ObjectSet_sub_486800(ObjectSet *procList, Object *proc) {
ObjectSet *newProcList;
-#line 574
- IRO_ASSERT(procList != NULL);
- IRO_ASSERT(proc != NULL);
+ IRO_ASSERT(574, procList != NULL);
+ IRO_ASSERT(575, proc != NULL);
if (procList->proc) {
newProcList = ObjectSet_New();
@@ -525,9 +496,8 @@ inline void ObjectSet_sub_486800(ObjectSet *procList, Object *proc) {
}
inline void ObjectSet_sub_4867D0(ObjectSet *procList, Object *proc) {
-#line 592
- IRO_ASSERT(procList != NULL);
- IRO_ASSERT(proc != NULL);
+ IRO_ASSERT(592, procList != NULL);
+ IRO_ASSERT(593, proc != NULL);
if (!ObjectSet_sub_485020(procList, proc))
ObjectSet_sub_486800(procList, proc);
@@ -537,9 +507,8 @@ inline void ObjectSet_Remove(ObjectSet *procList, Object *proc) {
ObjectSet *prev;
ObjectSet *tmp;
-#line 605
- IRO_ASSERT(procList != NULL);
- IRO_ASSERT(proc != NULL);
+ IRO_ASSERT(605, procList != NULL);
+ IRO_ASSERT(606, proc != NULL);
prev = NULL;
while (procList && procList->proc) {
@@ -571,33 +540,29 @@ inline void ObjectSet_Remove(ObjectSet *procList, Object *proc) {
}
inline void ObjectSet_RemoveAll(ObjectSet *procList) {
-#line 645
- IRO_ASSERT(procList != NULL);
+ IRO_ASSERT(645, 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);
+ IRO_ASSERT(655, proc != NULL);
+ IRO_ASSERT(656, 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);
+ IRO_ASSERT(663, proc != NULL);
+ IRO_ASSERT(664, 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);
+ IRO_ASSERT(671, dest != NULL);
+ IRO_ASSERT(672, src != NULL);
if (dest->proc)
ObjectSet_ForEach(src, ObjectSet_AddSetAction, dest);
@@ -606,17 +571,15 @@ inline void ObjectSet_sub_48C590(ObjectSet *dest, ObjectSet *src) {
}
inline void ObjectSet_RemoveSetAction(Object *proc, void *refcon) {
-#line 682
- IRO_ASSERT(proc != NULL);
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(682, proc != NULL);
+ IRO_ASSERT(683, 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);
+ IRO_ASSERT(690, dest != NULL);
+ IRO_ASSERT(691, src != NULL);
ObjectSet_ForEach(src, ObjectSet_RemoveSetAction, dest);
}
@@ -624,9 +587,8 @@ inline void ObjectSet_removeiter_sub_48C890(ObjectSet *dest, ObjectSet *src) {
inline Boolean ObjectSet_sub_484FA0(ObjectSet *os1, ObjectSet *os2) {
ObjectSet *scan;
-#line 700
- IRO_ASSERT(os1 != NULL);
- IRO_ASSERT(os2 != NULL);
+ IRO_ASSERT(700, os1 != NULL);
+ IRO_ASSERT(701, os2 != NULL);
if (os1 == os2)
return 1;
@@ -647,8 +609,7 @@ inline Boolean ObjectSet_sub_484FA0(ObjectSet *os1, ObjectSet *os2) {
inline ExtendedParam *ExtendedParam_New(void) {
ExtendedParam *ep = IRO_malloc(sizeof(ExtendedParam));
-#line 755
- IRO_ASSERT(ep != NULL);
+ IRO_ASSERT(755, ep != NULL);
#ifdef IRO_DEBUG
ep->objectSet = NULL;
#endif
@@ -656,18 +617,17 @@ inline ExtendedParam *ExtendedParam_New(void) {
}
inline void ExtendedParam_Delete(ExtendedParam *ep) {
- IRO_ASSERT(ep != NULL);
- IRO_ASSERT(ep->objectSet == NULL);
+ IRO_ASSERT(762, ep != NULL);
+ IRO_ASSERT(763, 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);
+ IRO_ASSERT(777, ep != NULL);
+ IRO_ASSERT(778, obj != NULL);
+ IRO_ASSERT(779, obj->extParam == NULL);
+ IRO_ASSERT(780, stExtendedParamNum < ((uint32) -1) / 2 - 1);
ep->objectSet = ObjectSet_New();
ObjectSet_Init(ep->objectSet);
@@ -682,7 +642,7 @@ inline void ExtendedParam_TermAction(Object *obj, void *refcon) {
}
inline void ExtendedParam_Term(ExtendedParam *ep) {
- IRO_ASSERT(ep != NULL);
+ IRO_ASSERT(800, ep != NULL);
ObjectSet_ForEach(ep->objectSet, ExtendedParam_TermAction, NULL);
ObjectSet_Term(ep->objectSet);
@@ -693,11 +653,10 @@ inline void ExtendedParam_Term(ExtendedParam *ep) {
}
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);
+ IRO_ASSERT(841, ep1 != NULL);
+ IRO_ASSERT(842, ep2 != NULL);
+ IRO_ASSERT(843, ep1->objectSet != NULL);
+ IRO_ASSERT(844, ep2->objectSet != NULL);
if (ep1 == ep2)
return 1;
@@ -706,17 +665,15 @@ inline Boolean ExtendedParams_Equal(ExtendedParam *ep1, ExtendedParam *ep2) {
}
inline ExtendedParam *ExtendedParam_FindByObject(Object *obj) {
-#line 856
- IRO_ASSERT(obj != NULL);
+ IRO_ASSERT(856, 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);
+ IRO_ASSERT(863, ep != NULL);
+ IRO_ASSERT(864, ep->objectSet != NULL);
+ IRO_ASSERT(865, obj != NULL);
ObjectSet_sub_4867D0(ep->objectSet, obj);
obj->extParam = ep;
@@ -727,25 +684,22 @@ inline void ExtendedParam_RemoveObjectSetAction(Object *object, void *refcon) {
}
inline void EP_sub_48C850(ExtendedParam *ep, ObjectSet *objSet) {
-#line 888
- IRO_ASSERT(ep != NULL);
- IRO_ASSERT(ep->objectSet != NULL);
- IRO_ASSERT(objSet != NULL);
+ IRO_ASSERT(888, ep != NULL);
+ IRO_ASSERT(889, ep->objectSet != NULL);
+ IRO_ASSERT(890, 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);
+ IRO_ASSERT(898, ep != NULL);
return ep->objectSet;
}
inline uint32 ExtendedParam_sub_489110(ExtendedParam *ep) {
-#line 905
- IRO_ASSERT(ep != NULL);
+ IRO_ASSERT(905, ep != NULL);
return ep->x4;
}
@@ -753,8 +707,7 @@ inline uint32 ExtendedParam_sub_489110(ExtendedParam *ep) {
inline ExtendedParamSet *AllocsExtParamSet_sub_4876C0(void) {
ExtendedParamSet *epList = IRO_malloc(sizeof(ExtendedParamSet));
-#line 924
- IRO_ASSERT(epList != NULL);
+ IRO_ASSERT(924, epList != NULL);
#ifdef IRO_DEBUG
epList->ep = NULL;
epList->otherEps = NULL;
@@ -763,24 +716,21 @@ inline ExtendedParamSet *AllocsExtParamSet_sub_4876C0(void) {
}
inline void FreesExtParamSet_sub_48CAE0(ExtendedParamSet *epList) {
-#line 936
- IRO_ASSERT(epList != NULL);
- IRO_ASSERT(epList->ep == NULL);
- IRO_ASSERT(epList->otherEps == NULL);
+ IRO_ASSERT(936, epList != NULL);
+ IRO_ASSERT(937, epList->ep == NULL);
+ IRO_ASSERT(938, 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);
+ IRO_ASSERT(948, epList != NULL);
epList->ep = NULL;
epList->otherEps = NULL;
}
inline void TermsExtParamSet_sub_48CB00(ExtendedParamSet *epList) {
-#line 966
- IRO_ASSERT(epList != NULL);
+ IRO_ASSERT(966, epList != NULL);
ExtendedParamSet_RemoveAll(epList);
#ifdef IRO_DEBUG
epList->ep = NULL;
@@ -789,9 +739,8 @@ inline void TermsExtParamSet_sub_48CB00(ExtendedParamSet *epList) {
}
inline void MaybeWalkExtParamSet_sub_48CBE0(ExtendedParamSet *epList, void (*action)(ExtendedParam *, void *), void *refcon) {
-#line 1010
- IRO_ASSERT(epList != NULL);
- IRO_ASSERT(action != NULL);
+ IRO_ASSERT(1010, epList != NULL);
+ IRO_ASSERT(1011, action != NULL);
while (epList && epList->ep) {
action(epList->ep, refcon);
@@ -800,9 +749,8 @@ inline void MaybeWalkExtParamSet_sub_48CBE0(ExtendedParamSet *epList, void (*act
}
inline ExtendedParam *ExtParamSet_sub_4876D0(ExtendedParamSet *epList, ExtendedParam *ep) {
-#line 1022
- IRO_ASSERT(epList != NULL);
- IRO_ASSERT(ep != NULL);
+ IRO_ASSERT(1022, epList != NULL);
+ IRO_ASSERT(1023, ep != NULL);
while (epList && epList->ep) {
if (epList->ep == ep)
@@ -814,9 +762,8 @@ inline ExtendedParam *ExtParamSet_sub_4876D0(ExtendedParamSet *epList, ExtendedP
}
inline void ExtParamSet_sub_487660(ExtendedParamSet *epList, ExtendedParam *ep) {
-#line 1056
- IRO_ASSERT(epList != NULL);
- IRO_ASSERT(ep != NULL);
+ IRO_ASSERT(1056, epList != NULL);
+ IRO_ASSERT(1057, ep != NULL);
if (epList->ep) {
ExtendedParamSet *newSet = AllocsExtParamSet_sub_4876C0();
@@ -830,9 +777,8 @@ inline void ExtParamSet_sub_487660(ExtendedParamSet *epList, ExtendedParam *ep)
}
inline void ExtParamSet_sub_487630(ExtendedParamSet *epList, ExtendedParam *ep) {
-#line 1076
- IRO_ASSERT(epList != NULL);
- IRO_ASSERT(ep != NULL);
+ IRO_ASSERT(1076, epList != NULL);
+ IRO_ASSERT(1077, ep != NULL);
if (!ExtParamSet_sub_4876D0(epList, ep))
ExtParamSet_sub_487660(epList, ep);
@@ -842,9 +788,8 @@ inline void ExtendedParamSet_Remove(ExtendedParamSet *epList, ExtendedParam *ep)
ExtendedParamSet *prev;
ExtendedParamSet *tmp;
-#line 1089
- IRO_ASSERT(epList != NULL);
- IRO_ASSERT(ep != NULL);
+ IRO_ASSERT(1089, epList != NULL);
+ IRO_ASSERT(1090, ep != NULL);
prev = NULL;
while (epList && epList->ep) {
@@ -876,8 +821,7 @@ inline void ExtendedParamSet_Remove(ExtendedParamSet *epList, ExtendedParam *ep)
}
inline void ExtendedParamSet_RemoveAll(ExtendedParamSet *epList) {
-#line 1129
- IRO_ASSERT(epList != NULL);
+ IRO_ASSERT(1129, epList != NULL);
while (epList && epList->ep)
ExtendedParamSet_Remove(epList, epList->ep);
@@ -886,8 +830,7 @@ inline void ExtendedParamSet_RemoveAll(ExtendedParamSet *epList) {
inline PAHeapBlock *CreateUniqueHeapAlloc_sub_486420(void) {
PAHeapBlock *hb = IRO_malloc(sizeof(PAHeapBlock));
-#line 1225
- IRO_ASSERT(hb != NULL);
+ IRO_ASSERT(1225, hb != NULL);
#ifdef IRO_DEBUG
hb->parent = NULL;
#endif
@@ -895,16 +838,14 @@ inline PAHeapBlock *CreateUniqueHeapAlloc_sub_486420(void) {
}
inline void InitUniqueHeapAlloc_sub_486410(PAHeapBlock *hb, IROLinear *nd) {
-#line 1247
- IRO_ASSERT(hb != NULL);
+ IRO_ASSERT(1247, hb != NULL);
hb->x0 = nd;
}
inline Boolean PAHeapBlocks_Equal(PAHeapBlock *hb1, PAHeapBlock *hb2) {
-#line 1296
- IRO_ASSERT(hb1 != NULL);
- IRO_ASSERT(hb2 != NULL);
+ IRO_ASSERT(1296, hb1 != NULL);
+ IRO_ASSERT(1297, hb2 != NULL);
return (hb1 == hb2) || (hb1->x0 == hb2->x0);
}
@@ -912,8 +853,7 @@ inline Boolean PAHeapBlocks_Equal(PAHeapBlock *hb1, PAHeapBlock *hb2) {
inline PALocalVar *PALocalVar_New(void) {
PALocalVar *local = IRO_malloc(sizeof(PALocalVar));
-#line 1333
- IRO_ASSERT(local != NULL);
+ IRO_ASSERT(1333, local != NULL);
#ifdef IRO_DEBUG
local->parent = NULL;
local->nextSibling = NULL;
@@ -922,9 +862,8 @@ inline PALocalVar *PALocalVar_New(void) {
}
inline void PALocalVar_InitByObject(PALocalVar *local, Object *obj) {
-#line 1357
- IRO_ASSERT(local != NULL);
- IRO_ASSERT(obj != NULL);
+ IRO_ASSERT(1357, local != NULL);
+ IRO_ASSERT(1358, obj != NULL);
local->x0 = obj;
if (obj->name && obj->name->name) {
@@ -936,9 +875,8 @@ inline void PALocalVar_InitByObject(PALocalVar *local, Object *obj) {
}
inline void PALocalVar_InitByName(PALocalVar *local, char *name) {
-#line 1372
- IRO_ASSERT(local != NULL);
- IRO_ASSERT(name != NULL);
+ IRO_ASSERT(1372, local != NULL);
+ IRO_ASSERT(1373, name != NULL);
local->x0 = NULL;
local->x4 = IRO_malloc(strlen(name) + 1);
@@ -946,9 +884,8 @@ inline void PALocalVar_InitByName(PALocalVar *local, char *name) {
}
inline Boolean PALocalVars_Equal(PALocalVar *local1, PALocalVar *local2) {
-#line 1419
- IRO_ASSERT(local1 == NULL || local1 != NULL);
- IRO_ASSERT(local2 == NULL || local2 != NULL);
+ IRO_ASSERT(1419, local1 == NULL || local1 != NULL);
+ IRO_ASSERT(1420, local2 == NULL || local2 != NULL);
if (local1 == local2)
return 1;
@@ -964,30 +901,26 @@ inline Boolean PALocalVars_Equal(PALocalVar *local1, PALocalVar *local2) {
}
inline void PALocalVar_SetSth_sub_4847C0(PALocalVar *local, Object *obj) {
-#line 1436
- IRO_ASSERT(local != NULL);
- IRO_ASSERT(obj == NULL || obj != NULL);
+ IRO_ASSERT(1436, local != NULL);
+ IRO_ASSERT(1437, obj == NULL || obj != NULL);
local->x0 = obj;
}
inline Object *PALocalVar_Get0_sub_4847E0(PALocalVar *local) {
-#line 1444
- IRO_ASSERT(local != NULL);
+ IRO_ASSERT(1444, local != NULL);
return local->x0;
}
inline char *PALocalVar_Get4_sub_4847D0(PALocalVar *local) {
-#line 1451
- IRO_ASSERT(local != NULL);
+ IRO_ASSERT(1451, local != NULL);
return local->x4;
}
inline PAMemoryBlock *PAMemoryBlock_New(void) {
PAMemoryBlock *mb = IRO_malloc(sizeof(PAMemoryBlock));
-#line 1491
- IRO_ASSERT(mb != NULL);
+ IRO_ASSERT(1491, mb != NULL);
#ifdef IRO_DEBUG
mb->kind = PAMEMORYBLOCKKIND_INVALID;
#endif
@@ -995,16 +928,14 @@ inline PAMemoryBlock *PAMemoryBlock_New(void) {
}
inline void PAMemoryBlock_Delete(PAMemoryBlock *mb) {
-#line 1502
- IRO_ASSERT(mb != NULL);
- IRO_ASSERT(mb->kind == PAMEMORYBLOCKKIND_INVALID);
+ IRO_ASSERT(1502, mb != NULL);
+ IRO_ASSERT(1503, 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);
+ IRO_ASSERT(1513, mb != NULL);
+ IRO_ASSERT(1514, thing == NULL || thing != NULL);
mb->kind = kind;
switch (mb->kind) {
@@ -1024,14 +955,12 @@ inline void PAMemoryBlock_Init(PAMemoryBlock *mb, PAMemoryBlockKind kind, void *
mb->u.x6 = (void *) thing;
break;
default:
-#line 1535
- CError_FATAL();
+ CError_FATAL(1535);
}
}
inline void PAMemoryBlock_Term(PAMemoryBlock *mb) {
-#line 1552
- IRO_ASSERT(mb != NULL);
+ IRO_ASSERT(1552, mb != NULL);
#ifdef IRO_DEBUG
mb->kind = PAMEMORYBLOCKKIND_INVALID;
@@ -1039,9 +968,8 @@ inline void PAMemoryBlock_Term(PAMemoryBlock *mb) {
}
inline Boolean MemoryBlocks_Equal(PAMemoryBlock *mb1, PAMemoryBlock *mb2) {
-#line 1657
- IRO_ASSERT(mb1 == NULL || mb1 != NULL);
- IRO_ASSERT(mb2 == NULL || mb2 != NULL);
+ IRO_ASSERT(1657, mb1 == NULL || mb1 != NULL);
+ IRO_ASSERT(1658, mb2 == NULL || mb2 != NULL);
if (mb1 == mb2)
return 1;
@@ -1061,22 +989,19 @@ inline Boolean MemoryBlocks_Equal(PAMemoryBlock *mb1, PAMemoryBlock *mb2) {
case PAMEMORYBLOCKKIND_6:
return mb1->u.x6 == mb2->u.x6;
default:
-#line 1684
- CError_FATAL();
+ CError_FATAL(1684);
return 0;
}
}
inline PAMemoryBlockKind PAMemoryBlock_kind(PAMemoryBlock *mb) {
-#line 1692
- IRO_ASSERT(mb != NULL);
+ IRO_ASSERT(1692, mb != NULL);
return mb->kind;
}
inline void *PAMemoryBlock_thing(PAMemoryBlock *mb) {
-#line 1699
- IRO_ASSERT(mb != NULL);
+ IRO_ASSERT(1699, mb != NULL);
switch (mb->kind) {
case PAMEMORYBLOCKKIND_EXTENDEDPARAM:
@@ -1090,8 +1015,7 @@ inline void *PAMemoryBlock_thing(PAMemoryBlock *mb) {
case PAMEMORYBLOCKKIND_6:
return mb->u.x6;
default:
-#line 1719
- CError_FATAL();
+ CError_FATAL(1719);
return NULL;
}
}
@@ -1099,8 +1023,7 @@ inline void *PAMemoryBlock_thing(PAMemoryBlock *mb) {
inline LocationSet *LocationSet_New(void) {
LocationSet *ls = IRO_malloc(sizeof(LocationSet));
-#line 1767
- IRO_ASSERT(ls != NULL);
+ IRO_ASSERT(1767, ls != NULL);
#ifdef IRO_DEBUG
ls->block = NULL;
ls->rtype = NULL;
@@ -1111,23 +1034,21 @@ inline LocationSet *LocationSet_New(void) {
}
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_ASSERT(1781, ls != NULL);
+ IRO_ASSERT(1782, ls != stUnknownLs);
+ IRO_ASSERT(1783, ls->block == NULL);
+ IRO_ASSERT(1784, CInt64_IsZero(&ls->u.known.field));
+ IRO_ASSERT(1785, ls->u.known.stride == 0);
+ IRO_ASSERT(1786, 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);
+ IRO_ASSERT(1796, ls != NULL);
+ IRO_ASSERT(1797, ls != stUnknownLs);
+ IRO_ASSERT(1798, block != NULL);
+ IRO_ASSERT(1799, rtype == NULL || rtype != NULL);
ls->block = block;
ls->rtype = rtype;
ls->u.known.field = field;
@@ -1135,12 +1056,11 @@ inline void LocationSet_InitKnown(LocationSet *ls, PAMemoryBlock *block, CInt64
}
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);
+ IRO_ASSERT(1809, ls != NULL);
+ IRO_ASSERT(1810, ls != stUnknownLs);
+ IRO_ASSERT(1811, rtype == NULL || rtype != NULL);
+ IRO_ASSERT(1812, restriction == NULL || restriction != NULL);
+ IRO_ASSERT(1813, bitfieldOf == NULL || bitfieldOf != NULL);
LocationSet_Copy(ls, stUnknownLs);
ls->rtype = rtype;
@@ -1154,9 +1074,8 @@ inline void LocationSet_InitUnknown(LocationSet *ls, Type *rtype, PAMemoryBlock
}
inline void LocationSet_Copy(LocationSet *dest, LocationSet *src) {
-#line 1829
- IRO_ASSERT(src != NULL);
- IRO_ASSERT(dest != NULL);
+ IRO_ASSERT(1829, src != NULL);
+ IRO_ASSERT(1830, dest != NULL);
dest->block = src->block;
dest->rtype = src->rtype;
@@ -1176,9 +1095,8 @@ inline void LocationSet_Copy(LocationSet *dest, LocationSet *src) {
}
inline void LocationSet_Term(LocationSet *ls) {
-#line 1857
- IRO_ASSERT(ls != NULL);
- IRO_ASSERT(ls != stUnknownLs);
+ IRO_ASSERT(1857, ls != NULL);
+ IRO_ASSERT(1858, ls != stUnknownLs);
#ifdef IRO_DEBUG
if (LocationSet_IsUnknown(ls) && ls->u.unknown.bitfieldOf) {
@@ -1196,11 +1114,10 @@ inline Boolean LocationSets_Overlap(LocationSet *ls1, Type *rtype1, LocationSet
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);
+ IRO_ASSERT(1974, ls1 != NULL);
+ IRO_ASSERT(1975, rtype1 == NULL || rtype1 != NULL);
+ IRO_ASSERT(1976, ls2 != NULL);
+ IRO_ASSERT(1977, rtype2 == NULL || rtype2 != NULL);
if (ls1 == ls2)
return 1;
@@ -1296,9 +1213,8 @@ inline Boolean LocationSets_Overlap(LocationSet *ls1, Type *rtype1, LocationSet
}
inline Boolean LocationSets_Equal(LocationSet *ls1, LocationSet *ls2) {
-#line 2080
- IRO_ASSERT(ls1 != NULL);
- IRO_ASSERT(ls2 != NULL);
+ IRO_ASSERT(2080, ls1 != NULL);
+ IRO_ASSERT(2081, ls2 != NULL);
return
(ls1 == ls2) ||
@@ -1319,9 +1235,8 @@ inline Boolean LocationSets_Equal(LocationSet *ls1, LocationSet *ls2) {
}
inline Boolean LocationSets_LookupCompatible(LocationSet *ls1, LocationSet *ls2) {
-#line 2119
- IRO_ASSERT(ls1 != NULL);
- IRO_ASSERT(ls2 != NULL);
+ IRO_ASSERT(2119, ls1 != NULL);
+ IRO_ASSERT(2120, ls2 != NULL);
if (
(ls1 == ls2) ||
@@ -1363,11 +1278,10 @@ inline Boolean LocationSet_Contains(LocationSet *ls1, Type *rtype1, LocationSet
CInt64 longsize1;
CInt64 longsize2;
-#line 2168
- IRO_ASSERT(ls1 != NULL);
- IRO_ASSERT(ls2 != NULL);
- IRO_ASSERT(rtype1 != NULL);
- IRO_ASSERT(rtype2 != NULL);
+ IRO_ASSERT(2168, ls1 != NULL);
+ IRO_ASSERT(2169, ls2 != NULL);
+ IRO_ASSERT(2170, rtype1 != NULL);
+ IRO_ASSERT(2171, rtype2 != NULL);
if (ls1 == ls2)
return 1;
@@ -1401,8 +1315,7 @@ inline Boolean LocationSet_Contains(LocationSet *ls1, Type *rtype1, LocationSet
}
inline Boolean LocationSet_IsUnknown(LocationSet *ls) {
-#line 2233
- IRO_ASSERT(ls != NULL);
+ IRO_ASSERT(2233, ls != NULL);
return (ls == stUnknownLs) || (ls->block == stUnknownMb);
}
@@ -1417,73 +1330,64 @@ inline Boolean LocationSet_sub_48AF30(LocationSet *ls) {
}
inline void LocationSet_SetRtype(LocationSet *ls, Type *rtype) {
-#line 2263
- IRO_ASSERT(ls != NULL);
- IRO_ASSERT(ls != stUnknownLs);
- IRO_ASSERT(rtype != NULL);
+ IRO_ASSERT(2263, ls != NULL);
+ IRO_ASSERT(2264, ls != stUnknownLs);
+ IRO_ASSERT(2265, 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));
+ IRO_ASSERT(2272, ls != NULL);
+ IRO_ASSERT(2273, !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));
+ IRO_ASSERT(2280, ls != NULL);
+ IRO_ASSERT(2281, !LocationSet_IsUnknown(ls));
ls->u.known.stride = stride;
}
inline PAMemoryBlock *LocationSet_block(LocationSet *ls) {
-#line 2298
- IRO_ASSERT(ls != NULL);
+ IRO_ASSERT(2298, ls != NULL);
return ls->block;
}
inline Type *LocationSet_rtype(LocationSet *ls) {
-#line 2306
- IRO_ASSERT(ls != NULL);
- IRO_ASSERT(ls != stUnknownLs);
+ IRO_ASSERT(2306, ls != NULL);
+ IRO_ASSERT(2307, ls != stUnknownLs);
return ls->rtype;
}
inline CInt64 LocationSet_field(LocationSet *ls) {
-#line 2314
- IRO_ASSERT(ls != NULL);
- IRO_ASSERT(!LocationSet_IsUnknown(ls));
+ IRO_ASSERT(2314, ls != NULL);
+ IRO_ASSERT(2315, !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));
+ IRO_ASSERT(2322, ls != NULL);
+ IRO_ASSERT(2323, !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));
+ IRO_ASSERT(2330, ls != NULL);
+ IRO_ASSERT(2331, 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));
+ IRO_ASSERT(2338, ls != NULL);
+ IRO_ASSERT(2339, LocationSet_IsUnknown(ls));
return ls->u.unknown.bitfieldOf;
}
@@ -1491,8 +1395,7 @@ inline LocationSet *LocationSet_bitfieldOf(LocationSet *ls) {
inline LocationSetSet *LocationSetSet_New() {
LocationSetSet *lss = IRO_malloc(sizeof(LocationSetSet));
-#line 2356
- IRO_ASSERT(lss != NULL);
+ IRO_ASSERT(2356, lss != NULL);
#ifdef IRO_DEBUG
lss->loc = NULL;
lss->otherLocs = NULL;
@@ -1502,18 +1405,16 @@ inline LocationSetSet *LocationSetSet_New() {
}
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_ASSERT(2369, lss != NULL);
+ IRO_ASSERT(2370, lss->loc == NULL);
+ IRO_ASSERT(2371, lss->otherLocs == NULL);
+ IRO_ASSERT(2372, lss->count == 0);
IRO_DEBUG_CLEAR(lss, sizeof(LocationSetSet));
IRO_free(lss);
}
inline void LocationSetSet_Init(LocationSetSet *lss) {
-#line 2382
- IRO_ASSERT(lss != NULL);
+ IRO_ASSERT(2382, lss != NULL);
lss->loc = NULL;
lss->otherLocs = NULL;
@@ -1521,9 +1422,8 @@ inline void LocationSetSet_Init(LocationSetSet *lss) {
}
inline void LocationSetSet_Copy(LocationSetSet *dest, LocationSetSet *src) {
-#line 2391
- IRO_ASSERT(dest != NULL);
- IRO_ASSERT(src != NULL);
+ IRO_ASSERT(2391, dest != NULL);
+ IRO_ASSERT(2392, src != NULL);
dest->loc = NULL;
dest->otherLocs = NULL;
@@ -1532,8 +1432,7 @@ inline void LocationSetSet_Copy(LocationSetSet *dest, LocationSetSet *src) {
}
inline void LocationSetSet_Term(LocationSetSet *lss) {
-#line 2402
- IRO_ASSERT(lss != NULL);
+ IRO_ASSERT(2402, lss != NULL);
LocationSetSet_RemoveAll(lss);
@@ -1545,10 +1444,9 @@ inline void LocationSetSet_Term(LocationSetSet *lss) {
}
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);
+ IRO_ASSERT(2446, lss != NULL);
+ IRO_ASSERT(2447, action != NULL);
+ IRO_ASSERT(2448, refcon == NULL || refcon != NULL);
while (lss && lss->loc) {
action(lss->loc, refcon);
@@ -1557,9 +1455,8 @@ inline void LocationSetSet_ForEach(LocationSetSet *lss, void (*action)(LocationS
}
inline LocationSet *LocationSetSet_Find(LocationSetSet *lss, LocationSet *ls) {
-#line 2458
- IRO_ASSERT(lss != NULL);
- IRO_ASSERT(ls != NULL);
+ IRO_ASSERT(2458, lss != NULL);
+ IRO_ASSERT(2459, ls != NULL);
while (lss && lss->loc) {
if (LocationSets_Equal(lss->loc, ls))
@@ -1571,8 +1468,7 @@ inline LocationSet *LocationSetSet_Find(LocationSetSet *lss, LocationSet *ls) {
}
inline LocationSet *LocationSetSet_FindUnknown(LocationSetSet *lss) {
-#line 2470
- IRO_ASSERT(lss != NULL);
+ IRO_ASSERT(2470, lss != NULL);
if (!lss->loc)
return stUnknownLs;
@@ -1587,15 +1483,13 @@ inline LocationSet *LocationSetSet_FindUnknown(LocationSetSet *lss) {
}
inline LocationSet *LocationSetSet_FindFirst(LocationSetSet *lss) {
-#line 2498
- IRO_ASSERT(lss != NULL);
+ IRO_ASSERT(2498, lss != NULL);
return lss->loc;
}
inline int LocationSetSet_Count(LocationSetSet *lss) {
-#line 2505
- IRO_ASSERT(lss != NULL);
+ IRO_ASSERT(2505, lss != NULL);
return lss->count;
}
@@ -1606,9 +1500,8 @@ inline void LocationSetSet_RemoveAllWithMemoryBlock(LocationSetSet *lss, PAMemor
LocationSetSet *next;
LocationSetSet *tmp;
-#line 2514
- IRO_ASSERT(lss != NULL);
- IRO_ASSERT(block != NULL);
+ IRO_ASSERT(2514, lss != NULL);
+ IRO_ASSERT(2515, block != NULL);
first = lss;
prev = NULL;
@@ -1649,9 +1542,8 @@ inline void LocationSetSet_RemoveAllWithMemoryBlock(LocationSetSet *lss, PAMemor
}
inline void LocationSetSet_SimpleAdd(LocationSetSet *lss, LocationSet *ls) {
-#line 2572
- IRO_ASSERT(lss != NULL);
- IRO_ASSERT(ls != NULL);
+ IRO_ASSERT(2572, lss != NULL);
+ IRO_ASSERT(2573, ls != NULL);
if (!LocationSet_IsUnknown(ls) && lss->count < 4) {
LocationSet *ls2;
@@ -1692,9 +1584,8 @@ inline void LocationSetSet_SimpleAdd(LocationSetSet *lss, LocationSet *ls) {
}
inline void LocationSetSet_Add(LocationSetSet *lss, LocationSet *ls) {
-#line 2622
- IRO_ASSERT(lss != NULL);
- IRO_ASSERT(ls != NULL);
+ IRO_ASSERT(2622, lss != NULL);
+ IRO_ASSERT(2623, ls != NULL);
if (!lss->loc || (!LocationSet_IsUnknown(lss->loc) && !LocationSetSet_Find(lss, ls))) {
if (!LocationSet_IsUnknown(ls) && ls->u.known.stride)
@@ -1706,11 +1597,10 @@ inline void LocationSetSet_Add(LocationSetSet *lss, LocationSet *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);
+ IRO_ASSERT(2643, lss != NULL);
+ IRO_ASSERT(2644, rtype == NULL || rtype != NULL);
+ IRO_ASSERT(2645, restriction == NULL || restriction != NULL);
+ IRO_ASSERT(2646, bitfieldOf == NULL || bitfieldOf != NULL);
ls = LocationSet_New();
LocationSet_InitUnknown(ls, rtype, restriction, bitfieldOf);
@@ -1724,9 +1614,8 @@ inline void LocationSetSet_Remove(LocationSetSet *lss, LocationSet *ls) {
LocationSetSet *first;
LocationSetSet *tmp;
-#line 2659
- IRO_ASSERT(lss != NULL);
- IRO_ASSERT(ls != NULL);
+ IRO_ASSERT(2659, lss != NULL);
+ IRO_ASSERT(2660, ls != NULL);
first = lss;
prev = NULL;
@@ -1765,33 +1654,29 @@ inline void LocationSetSet_Remove(LocationSetSet *lss, LocationSet *ls) {
}
inline void LocationSetSet_RemoveAll(LocationSetSet *lss) {
-#line 2707
- IRO_ASSERT(lss != NULL);
+ IRO_ASSERT(2707, 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);
+ IRO_ASSERT(2717, ls != NULL);
+ IRO_ASSERT(2718, 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);
+ IRO_ASSERT(2725, ls != NULL);
+ IRO_ASSERT(2726, 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);
+ IRO_ASSERT(2733, dest != NULL);
+ IRO_ASSERT(2734, src != NULL);
if (dest->count)
LocationSetSet_ForEach(src, LocationSetSet_AddSetAction, dest);
@@ -1800,25 +1685,22 @@ inline void LocationSetSet_AddSet(LocationSetSet *dest, LocationSetSet *src) {
}
inline void LocationSetSet_RemoveSetAction(LocationSet *ls, void *refcon) {
-#line 2744
- IRO_ASSERT(ls != NULL);
- IRO_ASSERT(refcon != NULL);
+ IRO_ASSERT(2744, ls != NULL);
+ IRO_ASSERT(2745, 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);
+ IRO_ASSERT(2752, dest != NULL);
+ IRO_ASSERT(2753, 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);
+ IRO_ASSERT(2826, lss1 != NULL);
+ IRO_ASSERT(2827, lss2 != NULL);
if (lss1 == lss2)
return 1;
@@ -1837,8 +1719,7 @@ inline Boolean LocationSetSets_Equal(LocationSetSet *lss1, LocationSetSet *lss2)
inline ParamMapping *ParamMapping_New(void) {
ParamMapping *pm = IRO_malloc(sizeof(ParamMapping));
-#line 2885
- IRO_ASSERT(pm != NULL);
+ IRO_ASSERT(2885, pm != NULL);
#ifdef IRO_DEBUG
pm->actual = NULL;
pm->formal = NULL;
@@ -1848,18 +1729,16 @@ inline ParamMapping *ParamMapping_New(void) {
}
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_ASSERT(2898, pm != NULL);
+ IRO_ASSERT(2899, pm->actual == NULL);
+ IRO_ASSERT(2900, pm->formal == NULL);
+ IRO_ASSERT(2901, 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);
+ IRO_ASSERT(2911, pm != NULL);
pm->actual = actual;
pm->formal = formal;
@@ -1867,9 +1746,8 @@ inline void ParamMapping_Init_PROBABLY(ParamMapping *pm, IROLinear *actual, Obje
}
inline void ParamMapping_Copy(ParamMapping *dest, ParamMapping *src) {
-#line 2920
- IRO_ASSERT(src != NULL);
- IRO_ASSERT(dest != NULL);
+ IRO_ASSERT(2920, src != NULL);
+ IRO_ASSERT(2921, dest != NULL);
dest->actual = src->actual;
dest->formal = src->formal;
@@ -1877,8 +1755,7 @@ inline void ParamMapping_Copy(ParamMapping *dest, ParamMapping *src) {
}
inline void ParamMapping_Term(ParamMapping *pm) {
-#line 2933
- IRO_ASSERT(pm != NULL);
+ IRO_ASSERT(2933, pm != NULL);
#ifdef IRO_DEBUG
pm->actual = NULL;
@@ -1888,22 +1765,19 @@ inline void ParamMapping_Term(ParamMapping *pm) {
}
inline void ParamMapping_SetExtended(ParamMapping *pm, ExtendedParam *ep) {
-#line 2992
- IRO_ASSERT(pm != NULL);
+ IRO_ASSERT(2992, pm != NULL);
pm->extended = ep;
}
inline IROLinear *ParamMapping_actual(ParamMapping *pm) {
-#line 2999
- IRO_ASSERT(pm != NULL);
+ IRO_ASSERT(2999, pm != NULL);
return pm->actual;
}
inline ExtendedParam *ParamMapping_extended(ParamMapping *pm) {
-#line 3011
- IRO_ASSERT(pm != NULL);
+ IRO_ASSERT(3011, pm != NULL);
return pm->extended;
}
@@ -1911,8 +1785,7 @@ inline ExtendedParam *ParamMapping_extended(ParamMapping *pm) {
inline ParamMappingFunction *ParamMappingFunction_New(void) {
ParamMappingFunction *pmf = IRO_malloc(sizeof(ParamMappingFunction));
-#line 3026
- IRO_ASSERT(pmf != NULL);
+ IRO_ASSERT(3026, pmf != NULL);
#ifdef IRO_DEBUG
pmf->mapping = NULL;
pmf->otherMappings = NULL;
@@ -1921,26 +1794,23 @@ inline ParamMappingFunction *ParamMappingFunction_New(void) {
}
inline void ParamMappingFunction_Delete(ParamMappingFunction *pmf) {
-#line 3039
- IRO_ASSERT(pmf != NULL);
- IRO_ASSERT(pmf->mapping == NULL);
- IRO_ASSERT(pmf->otherMappings == NULL);
+ IRO_ASSERT(3039, pmf != NULL);
+ IRO_ASSERT(3040, pmf->mapping == NULL);
+ IRO_ASSERT(3041, pmf->otherMappings == NULL);
IRO_DEBUG_CLEAR(pmf, sizeof(ParamMappingFunction));
IRO_free(pmf);
}
inline void ParamMappingFunction_Init(ParamMappingFunction *pmf) {
-#line 3050
- IRO_ASSERT(pmf != NULL);
+ IRO_ASSERT(3050, 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);
+ IRO_ASSERT(3058, src != NULL);
+ IRO_ASSERT(3059, dest != NULL);
dest->mapping = NULL;
dest->otherMappings = NULL;
@@ -1948,8 +1818,7 @@ inline void ParamMappingFunction_Copy(ParamMappingFunction *dest, ParamMappingFu
}
inline void ParamMappingFunction_Term(ParamMappingFunction *pmf) {
-#line 3068
- IRO_ASSERT(pmf != NULL);
+ IRO_ASSERT(3068, pmf != NULL);
ParamMappingFunction_RemoveAll(pmf);
@@ -1960,10 +1829,9 @@ inline void ParamMappingFunction_Term(ParamMappingFunction *pmf) {
}
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);
+ IRO_ASSERT(3111, pmf != NULL);
+ IRO_ASSERT(3112, action != NULL);
+ IRO_ASSERT(3113, refcon == NULL || refcon != NULL);
while (pmf && pmf->mapping) {
action(pmf->mapping, refcon);
@@ -1972,9 +1840,8 @@ inline void pmf_sub_487C70(ParamMappingFunction *pmf, void (*action)(ParamMappin
}
inline ParamMapping *ParamMappingFunction_FindMappingByFormal(ParamMappingFunction *pmf, Object *formal) {
-#line 3123
- IRO_ASSERT(pmf != NULL);
- IRO_ASSERT(formal != NULL);
+ IRO_ASSERT(3123, pmf != NULL);
+ IRO_ASSERT(3124, formal != NULL);
while (pmf && pmf->mapping) {
if (pmf->mapping->formal == formal)
@@ -1988,9 +1855,8 @@ inline ParamMapping *ParamMappingFunction_FindMappingByFormal(ParamMappingFuncti
inline void Pmf_Add_sub_486610(ParamMappingFunction *pmf, ParamMapping *mapping) {
ParamMapping *existing;
-#line 3138
- IRO_ASSERT(pmf != NULL);
- IRO_ASSERT(mapping != NULL);
+ IRO_ASSERT(3138, pmf != NULL);
+ IRO_ASSERT(3139, mapping != NULL);
existing = ParamMappingFunction_FindMappingByFormal(pmf, mapping->formal);
if (!existing) {
@@ -2014,9 +1880,8 @@ inline void ParamMappingFunction_Remove(ParamMappingFunction *pmf, ParamMapping
ParamMappingFunction *prev;
ParamMappingFunction *tmp;
-#line 3170
- IRO_ASSERT(pmf != NULL);
- IRO_ASSERT(mapping != NULL);
+ IRO_ASSERT(3170, pmf != NULL);
+ IRO_ASSERT(3171, mapping != NULL);
prev = NULL;
while (pmf && pmf->mapping) {
@@ -2051,25 +1916,22 @@ inline void ParamMappingFunction_Remove(ParamMappingFunction *pmf, ParamMapping
}
inline void ParamMappingFunction_RemoveAll(ParamMappingFunction *pmf) {
-#line 3213
- IRO_ASSERT(pmf != NULL);
+ IRO_ASSERT(3213, 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);
+ IRO_ASSERT(3223, mapping != NULL);
+ IRO_ASSERT(3224, 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);
+ IRO_ASSERT(3231, dest != NULL);
+ IRO_ASSERT(3232, src != NULL);
pmf_sub_487C70(src, ParamMappingFunction_AddFunctionAction, dest);
}
@@ -2077,8 +1939,7 @@ inline void ParamMappingFunction_AddAllMaybe_sub_487C50(ParamMappingFunction *de
inline PointsToEntry *PointsToEntry_New(void) {
PointsToEntry *pte = IRO_malloc(sizeof(PointsToEntry));
-#line 3288
- IRO_ASSERT(pte != NULL);
+ IRO_ASSERT(3288, pte != NULL);
#ifdef IRO_DEBUG
pte->loc = NULL;
pte->locs = NULL;
@@ -2087,20 +1948,18 @@ inline PointsToEntry *PointsToEntry_New(void) {
}
inline void PointsToEntry_Delete(PointsToEntry *pte) {
-#line 3300
- IRO_ASSERT(pte != NULL);
- IRO_ASSERT(pte->loc == NULL);
- IRO_ASSERT(pte->locs == NULL);
+ IRO_ASSERT(3300, pte != NULL);
+ IRO_ASSERT(3301, pte->loc == NULL);
+ IRO_ASSERT(3302, 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);
+ IRO_ASSERT(3312, pte != NULL);
+ IRO_ASSERT(3313, loc != NULL);
+ IRO_ASSERT(3314, !LocationSet_IsUnknown(loc));
+ IRO_ASSERT(3315, locs != NULL);
pte->loc = LocationSet_New();
LocationSet_Copy(pte->loc, loc);
@@ -2110,16 +1969,14 @@ inline void PointsToEntry_Init(PointsToEntry *pte, LocationSet *loc, LocationSet
}
inline void PointsToEntry_Copy(PointsToEntry *dest, PointsToEntry *src) {
-#line 3325
- IRO_ASSERT(src != NULL);
- IRO_ASSERT(dest != NULL);
+ IRO_ASSERT(3325, src != NULL);
+ IRO_ASSERT(3326, dest != NULL);
PointsToEntry_Init(dest, src->loc, src->locs);
}
inline void PointsToEntry_Term(PointsToEntry *pte) {
-#line 3333
- IRO_ASSERT(pte != NULL);
+ IRO_ASSERT(3333, pte != NULL);
LocationSet_Term(pte->loc);
LocationSet_Delete(pte->loc);
@@ -2133,9 +1990,8 @@ inline void PointsToEntry_Term(PointsToEntry *pte) {
}
inline Boolean PointsToEntries_Equal(PointsToEntry *pte1, PointsToEntry *pte2) {
-#line 3381
- IRO_ASSERT(pte1 != NULL);
- IRO_ASSERT(pte2 != NULL);
+ IRO_ASSERT(3381, pte1 != NULL);
+ IRO_ASSERT(3382, pte2 != NULL);
if (pte1 == pte2)
return 1;
@@ -2144,15 +2000,13 @@ inline Boolean PointsToEntries_Equal(PointsToEntry *pte1, PointsToEntry *pte2) {
}
inline LocationSet *PointsToEntry_loc(PointsToEntry *pte) {
-#line 3407
- IRO_ASSERT(pte != NULL);
+ IRO_ASSERT(3407, pte != NULL);
return pte->loc;
}
inline LocationSetSet *PointsToEntry_locs(PointsToEntry *pte) {
-#line 3414
- IRO_ASSERT(pte != NULL);
+ IRO_ASSERT(3414, pte != NULL);
return pte->locs;
}
@@ -2160,8 +2014,7 @@ inline LocationSetSet *PointsToEntry_locs(PointsToEntry *pte) {
inline PointsToFunction *PointsToFunction_New(void) {
PointsToFunction *pointsToFunc = IRO_malloc(sizeof(PointsToFunction));
-#line 3430
- IRO_ASSERT(pointsToFunc != NULL);
+ IRO_ASSERT(3430, pointsToFunc != NULL);
#ifdef IRO_DEBUG
pointsToFunc->pte = NULL;
pointsToFunc->otherPtes = NULL;
@@ -2170,26 +2023,23 @@ inline PointsToFunction *PointsToFunction_New(void) {
}
inline void PointsToFunction_Delete(PointsToFunction *pointsToFunc) {
-#line 3442
- IRO_ASSERT(pointsToFunc != NULL);
- IRO_ASSERT(pointsToFunc->pte == NULL);
- IRO_ASSERT(pointsToFunc->otherPtes == NULL);
+ IRO_ASSERT(3442, pointsToFunc != NULL);
+ IRO_ASSERT(3443, pointsToFunc->pte == NULL);
+ IRO_ASSERT(3444, pointsToFunc->otherPtes == NULL);
IRO_DEBUG_CLEAR(pointsToFunc, sizeof(PointsToFunction));
IRO_free(pointsToFunc);
}
inline void PointsToFunction_Init(PointsToFunction *pointsToFunc) {
-#line 3454
- IRO_ASSERT(pointsToFunc != NULL);
+ IRO_ASSERT(3454, 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);
+ IRO_ASSERT(3462, src != NULL);
+ IRO_ASSERT(3463, dest != NULL);
dest->pte = NULL;
dest->otherPtes = NULL;
@@ -2197,8 +2047,7 @@ inline void PointsToFunction_Copy(PointsToFunction *dest, PointsToFunction *src)
}
inline void PointsToFunction_Term(PointsToFunction *pointsToFunc) {
-#line 3472
- IRO_ASSERT(pointsToFunc != NULL);
+ IRO_ASSERT(3472, pointsToFunc != NULL);
PointsToFunction_RemoveAll(pointsToFunc);
@@ -2209,10 +2058,9 @@ inline void PointsToFunction_Term(PointsToFunction *pointsToFunc) {
}
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);
+ IRO_ASSERT(3515, pointsToFunc != NULL);
+ IRO_ASSERT(3516, action != NULL);
+ IRO_ASSERT(3517, refcon == NULL || refcon != NULL);
while (pointsToFunc && pointsToFunc->pte) {
action(pointsToFunc->pte, refcon);
@@ -2221,9 +2069,8 @@ inline void PointsToFunction_ForEach(PointsToFunction *pointsToFunc, void (*acti
}
inline PointsToEntry *PointsToFunction_FindByLocationSet(PointsToFunction *pointsToFunc, LocationSet *ls) {
-#line 3527
- IRO_ASSERT(pointsToFunc != NULL);
- IRO_ASSERT(ls != NULL);
+ IRO_ASSERT(3527, pointsToFunc != NULL);
+ IRO_ASSERT(3528, ls != NULL);
while (pointsToFunc && pointsToFunc->pte) {
if (LocationSets_Equal(pointsToFunc->pte->loc, ls))
@@ -2235,16 +2082,14 @@ inline PointsToEntry *PointsToFunction_FindByLocationSet(PointsToFunction *point
}
inline PointsToEntry *PointsToFunction_FindFirst(PointsToFunction *pointsToFunc) {
-#line 3539
- IRO_ASSERT(pointsToFunc != NULL);
+ IRO_ASSERT(3539, pointsToFunc != NULL);
return pointsToFunc->pte;
}
inline PointsToEntry *PointsToFunction_FindByLookupCompatibleLocationSet(PointsToFunction *pointsToFunc, LocationSet *ls) {
-#line 3546
- IRO_ASSERT(pointsToFunc != NULL);
- IRO_ASSERT(ls != NULL);
+ IRO_ASSERT(3546, pointsToFunc != NULL);
+ IRO_ASSERT(3547, ls != NULL);
while (pointsToFunc && pointsToFunc->pte) {
if (ls->u.known.stride) {
@@ -2260,10 +2105,9 @@ inline PointsToEntry *PointsToFunction_FindByLookupCompatibleLocationSet(PointsT
}
inline PointsToEntry *PointsToFunction_FindContainingLocationSet(PointsToFunction *pointsToFunc, LocationSet *ls, Type *rtype) {
-#line 3565
- IRO_ASSERT(pointsToFunc != NULL);
- IRO_ASSERT(ls != NULL);
- IRO_ASSERT(rtype != NULL);
+ IRO_ASSERT(3565, pointsToFunc != NULL);
+ IRO_ASSERT(3566, ls != NULL);
+ IRO_ASSERT(3567, rtype != NULL);
while (pointsToFunc && pointsToFunc->pte) {
if (pointsToFunc->pte->locs->loc && !LocationSet_IsUnknown(pointsToFunc->pte->locs->loc)) {
@@ -2284,18 +2128,16 @@ inline void PointsToFunction_RemoveOverlappingLocations(PointsToFunction *points
PointsToFunction *next;
PointsToFunction *tmp;
-#line 3601
- IRO_ASSERT(pointsToFunc != NULL);
- IRO_ASSERT(pte != NULL);
- IRO_ASSERT(pte->locs != NULL);
+ IRO_ASSERT(3601, pointsToFunc != NULL);
+ IRO_ASSERT(3602, pte != NULL);
+ IRO_ASSERT(3603, 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);
+ IRO_ASSERT(3614, ls != NULL);
prev = NULL;
while (pointsToFunc && pointsToFunc->pte) {
@@ -2352,15 +2194,14 @@ inline Boolean ShouldAddNewPointsToEntryToFunction(PointsToFunction *pointsToFun
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);
+ IRO_ASSERT(3675, pointsToFunc != NULL);
+ IRO_ASSERT(3676, pte != NULL);
+ IRO_ASSERT(3677, pte->locs != NULL);
+ IRO_ASSERT(3678, PointsToFunction_FindByLookupCompatibleLocationSet(pointsToFunc, pte->loc) == NULL);
+ IRO_ASSERT(3679, (unknown = LocationSetSet_FindFirst(pte->locs)) != NULL);
+ IRO_ASSERT(3680, LocationSet_IsUnknown(unknown));
+ IRO_ASSERT(3681, LocationSet_bitfieldOf(unknown) == NULL);
+ IRO_ASSERT(3682, LocationSet_restriction(unknown) == NULL);
if (pte->locs->loc && pte->locs->loc != stUnknownLs)
rtype1 = pte->locs->loc->rtype;
@@ -2368,8 +2209,7 @@ inline Boolean ShouldAddNewPointsToEntryToFunction(PointsToFunction *pointsToFun
rtype1 = NULL;
loc = pte->loc;
-#line 3693
- IRO_ASSERT(loc != NULL);
+ IRO_ASSERT(3693, loc != NULL);
isKnown = !LocationSet_IsUnknown(loc);
if (isKnown)
@@ -2410,9 +2250,8 @@ inline Boolean ShouldAddNewPointsToEntryToFunction(PointsToFunction *pointsToFun
inline Boolean PointsToFunction_SimpleAdd(PointsToFunction *pointsToFunc, PointsToEntry *pte) {
PointsToEntry *newPTE;
-#line 3741
- IRO_ASSERT(pointsToFunc != NULL);
- IRO_ASSERT(pte != NULL);
+ IRO_ASSERT(3741, pointsToFunc != NULL);
+ IRO_ASSERT(3742, pte != NULL);
newPTE = PointsToEntry_New();
PointsToEntry_Copy(newPTE, pte);
@@ -2428,9 +2267,8 @@ inline Boolean PointsToFunction_SimpleAdd(PointsToFunction *pointsToFunc, Points
}
inline Boolean PointsToFunction_Add(PointsToFunction *pointsToFunc, PointsToEntry *pte) {
-#line 3766
- IRO_ASSERT(pointsToFunc != NULL);
- IRO_ASSERT(pte != NULL);
+ IRO_ASSERT(3766, pointsToFunc != NULL);
+ IRO_ASSERT(3767, pte != NULL);
if (!PointsToFunction_FindByLookupCompatibleLocationSet(pointsToFunc, pte->loc)) {
LocationSet *ls;
@@ -2449,9 +2287,8 @@ inline Boolean PointsToFunction_Add(PointsToFunction *pointsToFunc, PointsToEntr
inline Boolean PointsToFunction_AddWithoutChecking(PointsToFunction *pointsToFunc, PointsToEntry *pte) {
LocationSet *ls;
-#line 3793
- IRO_ASSERT(pointsToFunc != NULL);
- IRO_ASSERT(pte != NULL);
+ IRO_ASSERT(3793, pointsToFunc != NULL);
+ IRO_ASSERT(3794, pte != NULL);
if (!(ls = LocationSetSet_FindFirst(pte->locs)) || !LocationSet_IsUnknown(ls) || LocationSet_bitfieldOf(ls) ||
LocationSet_restriction(ls) || ShouldAddNewPointsToEntryToFunction(pointsToFunc, pte)) {
@@ -2468,10 +2305,9 @@ inline void PointsToFunction_RemoveByLocationSet(PointsToFunction *pointsToFunc,
PointsToFunction *prev;
PointsToFunction *tmp;
-#line 3170
- IRO_ASSERT(pointsToFunc != NULL);
- IRO_ASSERT(ls != NULL);
- IRO_ASSERT(!LocationSet_IsUnknown(ls));
+ IRO_ASSERT(3170, pointsToFunc != NULL);
+ IRO_ASSERT(3171, ls != NULL);
+ IRO_ASSERT(3172, !LocationSet_IsUnknown(ls));
prev = NULL;
while (pointsToFunc && pointsToFunc->pte) {
@@ -2506,33 +2342,29 @@ inline void PointsToFunction_RemoveByLocationSet(PointsToFunction *pointsToFunc,
}
inline void PointsToFunction_RemoveAll(PointsToFunction *pointsToFunc) {
-#line 3862
- IRO_ASSERT(pointsToFunc != NULL);
+ IRO_ASSERT(3862, 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);
+ IRO_ASSERT(3872, pte != NULL);
+ IRO_ASSERT(3873, 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);
+ IRO_ASSERT(3880, pte != NULL);
+ IRO_ASSERT(3881, 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);
+ IRO_ASSERT(3888, dest != NULL);
+ IRO_ASSERT(3889, src != NULL);
if (dest->pte)
PointsToFunction_ForEach(src, PointsToFunction_AddFunctionAction, dest);
@@ -2589,9 +2421,8 @@ inline Boolean PointsToFunctions_Equal(PointsToFunction *pointsToFunc1, PointsTo
PointsToFunction *scan;
PointsToEntry *pte;
-#line 3968
- IRO_ASSERT(pointsToFunc1 != NULL);
- IRO_ASSERT(pointsToFunc2 != NULL);
+ IRO_ASSERT(3968, pointsToFunc1 != NULL);
+ IRO_ASSERT(3969, pointsToFunc2 != NULL);
if (pointsToFunc1 == pointsToFunc2)
return 1;
@@ -2618,8 +2449,7 @@ inline Boolean PointsToFunctions_Match(PointsToFunction *pointsToFunc1, PointsTo
inline PartialTransferFunction *PartialTransferFunction_New() {
PartialTransferFunction *ptf = IRO_malloc(sizeof(PartialTransferFunction));
-#line 4110
- IRO_ASSERT(ptf != NULL);
+ IRO_ASSERT(4110, ptf != NULL);
#ifdef IRO_DEBUG
ptf->initialPointsToFn = NULL;
ptf->finalPointsToFn = NULL;
@@ -2632,23 +2462,21 @@ inline PartialTransferFunction *PartialTransferFunction_New() {
}
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_ASSERT(4126, ptf != NULL);
+ IRO_ASSERT(4127, ptf->initialPointsToFn == NULL);
+ IRO_ASSERT(4128, ptf->finalPointsToFn == NULL);
+ IRO_ASSERT(4129, ptf->funcModifies == NULL);
+ IRO_ASSERT(4130, ptf->context.nd == NULL);
+ IRO_ASSERT(4131, ptf->context.ptf == NULL);
+ IRO_ASSERT(4132, 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);
+ IRO_ASSERT(4142, ptf != NULL);
+ IRO_ASSERT(4143, contextNd != NULL);
+ IRO_ASSERT(4144, contextPTF != NULL);
ptf->initialPointsToFn = PointsToFunction_New();
PointsToFunction_Init(ptf->initialPointsToFn);
@@ -2667,9 +2495,8 @@ inline void PartialTransferFunction_Init(PartialTransferFunction *ptf, IROLinear
}
inline void PartialTransferFunction_Copy(PartialTransferFunction *dest, PartialTransferFunction *src) {
-#line 4164
- IRO_ASSERT(src != NULL);
- IRO_ASSERT(dest != NULL);
+ IRO_ASSERT(4164, src != NULL);
+ IRO_ASSERT(4165, dest != NULL);
dest->initialPointsToFn = PointsToFunction_New();
PointsToFunction_Copy(dest->initialPointsToFn, src->initialPointsToFn);
@@ -2691,8 +2518,7 @@ inline void PartialTransferFunction_Copy(PartialTransferFunction *dest, PartialT
}
inline void PartialTransferFunction_Term(PartialTransferFunction *ptf) {
-#line 4190
- IRO_ASSERT(ptf != NULL);
+ IRO_ASSERT(4190, ptf != NULL);
PointsToFunction_Term(ptf->initialPointsToFn);
PointsToFunction_Delete(ptf->initialPointsToFn);
@@ -2719,29 +2545,25 @@ inline void PartialTransferFunction_Term(PartialTransferFunction *ptf) {
}
inline PointsToFunction *PartialTransferFunction_initialPointsToFn(PartialTransferFunction *ptf) {
-#line 4221
- IRO_ASSERT(ptf != NULL);
+ IRO_ASSERT(4221, ptf != NULL);
return ptf->initialPointsToFn;
}
inline PointsToFunction *PartialTransferFunction_finalPointsToFn(PartialTransferFunction *ptf) {
-#line 4227
- IRO_ASSERT(ptf != NULL);
+ IRO_ASSERT(4227, ptf != NULL);
return ptf->finalPointsToFn;
}
inline LocationSetSet *PTF_sub_48D750(PartialTransferFunction *ptf) {
-#line 4233
- IRO_ASSERT(ptf != NULL);
+ IRO_ASSERT(4233, ptf != NULL);
return ptf->funcModifies;
}
inline LocationSet *PartialTransferFunction_returnLocation(PartialTransferFunction *ptf) {
-#line 4249
- IRO_ASSERT(ptf != NULL);
+ IRO_ASSERT(4249, ptf != NULL);
if (!ptf->returnLocation) {
PAMemoryBlock *block;
@@ -2758,22 +2580,19 @@ inline LocationSet *PartialTransferFunction_returnLocation(PartialTransferFuncti
}
inline IROLinear *PTF_sub_48B980(PartialTransferFunction *ptf) {
-#line 4265
- IRO_ASSERT(ptf != NULL);
+ IRO_ASSERT(4265, ptf != NULL);
return ptf->context.nd;
}
inline PartialTransferFunction *PTF_sub_48B970(PartialTransferFunction *ptf) {
-#line 4271
- IRO_ASSERT(ptf != NULL);
+ IRO_ASSERT(4271, ptf != NULL);
return ptf->context.ptf;
}
inline void PartialTransferFunction_sub_48A610(PartialTransferFunction *ptf, Boolean value) {
-#line 4298
- IRO_ASSERT(ptf != NULL);
+ IRO_ASSERT(4298, ptf != NULL);
ptf->x10 = (value != 0) ? 1 : 0;
}
@@ -2781,8 +2600,7 @@ inline void PartialTransferFunction_sub_48A610(PartialTransferFunction *ptf, Boo
inline PTFList *PTFList_New(void) {
PTFList *ptfList = IRO_malloc(sizeof(PTFList));
-#line 4393
- IRO_ASSERT(ptfList != NULL);
+ IRO_ASSERT(4393, ptfList != NULL);
#ifdef IRO_DEBUG
ptfList->ptf = NULL;
ptfList->otherPTFs = NULL;
@@ -2791,25 +2609,22 @@ inline PTFList *PTFList_New(void) {
}
inline void PTFList_Delete(PTFList *ptfList) {
-#line 4405
- IRO_ASSERT(ptfList != NULL);
- IRO_ASSERT(ptfList->ptf == NULL);
- IRO_ASSERT(ptfList->otherPTFs == NULL);
+ IRO_ASSERT(4405, ptfList != NULL);
+ IRO_ASSERT(4406, ptfList->ptf == NULL);
+ IRO_ASSERT(4407, ptfList->otherPTFs == NULL);
IRO_DEBUG_CLEAR(ptfList, sizeof(PTFList));
IRO_free(ptfList);
}
inline void PTFList_Init(PTFList *ptfList) {
-#line 4417
- IRO_ASSERT(ptfList != NULL);
+ IRO_ASSERT(4417, ptfList != NULL);
ptfList->ptf = NULL;
ptfList->otherPTFs = NULL;
}
inline void PTFList_Term(PTFList *ptfList) {
-#line 4435
- IRO_ASSERT(ptfList != NULL);
+ IRO_ASSERT(4435, ptfList != NULL);
PTFList_RemoveAll(ptfList);
@@ -2820,10 +2635,9 @@ inline void PTFList_Term(PTFList *ptfList) {
}
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);
+ IRO_ASSERT(4478, ptfList != NULL);
+ IRO_ASSERT(4479, action != NULL);
+ IRO_ASSERT(4480, refcon == NULL || refcon != NULL);
while (ptfList && ptfList->ptf) {
action(ptfList->ptf, refcon);
@@ -2832,9 +2646,8 @@ inline void PTFList_ForEach(PTFList *ptfList, void (*action)(PartialTransferFunc
}
inline PartialTransferFunction *PTFList_sub_48A0F0(PTFList *ptfList, PartialTransferFunction *ptf) {
-#line 4490
- IRO_ASSERT(ptfList != NULL);
- IRO_ASSERT(ptf != NULL);
+ IRO_ASSERT(4490, ptfList != NULL);
+ IRO_ASSERT(4491, ptf != NULL);
while (ptfList && ptfList->ptf) {
if (ptfList->ptf == ptf)
@@ -2847,16 +2660,14 @@ inline PartialTransferFunction *PTFList_sub_48A0F0(PTFList *ptfList, PartialTran
}
inline PartialTransferFunction *PTFList_FindFirst(PTFList *ptfList) {
-#line 4502
- IRO_ASSERT(ptfList != NULL);
+ IRO_ASSERT(4502, ptfList != NULL);
return ptfList->ptf;
}
inline void PTFList_sub_48A080(PTFList *ptfList, PartialTransferFunction *ptf) {
-#line 4511
- IRO_ASSERT(ptfList != NULL);
- IRO_ASSERT(ptf != NULL);
+ IRO_ASSERT(4511, ptfList != NULL);
+ IRO_ASSERT(4512, ptf != NULL);
if (ptfList->ptf) {
PTFList *newList = PTFList_New();
@@ -2870,9 +2681,8 @@ inline void PTFList_sub_48A080(PTFList *ptfList, PartialTransferFunction *ptf) {
}
inline void PTFList_sub_48A050(PTFList *ptfList, PartialTransferFunction *ptf) {
-#line 4529
- IRO_ASSERT(ptfList != NULL);
- IRO_ASSERT(ptf != NULL);
+ IRO_ASSERT(4529, ptfList != NULL);
+ IRO_ASSERT(4530, ptf != NULL);
if (!PTFList_sub_48A0F0(ptfList, ptf))
PTFList_sub_48A080(ptfList, ptf);
@@ -2882,9 +2692,8 @@ inline void PTFList_Remove(PTFList *ptfList, PartialTransferFunction *ptf) {
PTFList *prev;
PTFList *tmp;
-#line 4542
- IRO_ASSERT(ptfList != NULL);
- IRO_ASSERT(ptf != NULL);
+ IRO_ASSERT(4542, ptfList != NULL);
+ IRO_ASSERT(4543, ptf != NULL);
prev = NULL;
while (ptfList && ptfList->ptf) {
@@ -2917,8 +2726,7 @@ inline void PTFList_Remove(PTFList *ptfList, PartialTransferFunction *ptf) {
}
inline void PTFList_RemoveAll(PTFList *ptfList) {
-#line 4582
- IRO_ASSERT(ptfList != NULL);
+ IRO_ASSERT(4582, ptfList != NULL);
while (ptfList && ptfList->ptf)
PTFList_Remove(ptfList, ptfList->ptf);
diff --git a/compiler_and_linker/unsorted/IroTransform.c b/compiler_and_linker/unsorted/IroTransform.c
index 710f2d8..e63421b 100644
--- a/compiler_and_linker/unsorted/IroTransform.c
+++ b/compiler_and_linker/unsorted/IroTransform.c
@@ -1,3 +1,2794 @@
#include "compiler/IroTransform.h"
+#include "compiler/CError.h"
+#include "compiler/CFunc.h"
+#include "compiler/CInt64.h"
+#include "compiler/CIRTransform.h"
+#include "compiler/CMachine.h"
+#include "compiler/CPrep.h"
+#include "compiler/CompilerTools.h"
+#include "compiler/IroDump.h"
+#include "compiler/IroLinearForm.h"
+#include "compiler/IroMalloc.h"
+#include "compiler/IroPointerAnalysis.h"
+#include "compiler/IROUseDef.h"
+#include "compiler/IroUtil.h"
+#include "compiler/IroVars.h"
+#include "compiler/enode.h"
+#include "compiler/types.h"
-// TODO
+ENodeType ExprType;
+ENode *IndirectRef;
+Boolean FirstTime;
+CInt64 OperandConst;
+Object *OperandObject;
+ENodeList *FirstAddend;
+ENodeList *LastAddend;
+static ENodeType AssignmentOp[MAXEXPR];
+static ENodeType ComplementaryOpLogical[MAXEXPR];
+static ENodeType ComplementaryOp[MAXEXPR];
+
+// forward decls
+static void DoDiadic(IROLinear *nd);
+
+static int GetTypeSize(Type *type) {
+ if (type->size == 1)
+ return 0;
+ if (type->size == 2)
+ return 1;
+ if (type->size == 4)
+ return 2;
+ if (type->size == 8)
+ return 3;
+ return -1;
+}
+
+void IRO_InitializeAssignmentOpArray(void) {
+ int i;
+
+ for (i = 0; i < MAXEXPR; i++)
+ AssignmentOp[i] = MAXEXPR;
+
+ AssignmentOp[EPOSTINC] = MAXEXPR;
+ AssignmentOp[EPOSTDEC] = MAXEXPR;
+ AssignmentOp[EPREINC] = MAXEXPR;
+ AssignmentOp[EPREDEC] = MAXEXPR;
+ AssignmentOp[EINDIRECT] = MAXEXPR;
+ AssignmentOp[EMONMIN] = MAXEXPR;
+ AssignmentOp[EBINNOT] = MAXEXPR;
+ AssignmentOp[ELOGNOT] = MAXEXPR;
+ AssignmentOp[EFORCELOAD] = MAXEXPR;
+ AssignmentOp[EMUL] = EMULASS;
+ AssignmentOp[EMULV] = MAXEXPR;
+ AssignmentOp[EDIV] = EDIVASS;
+ AssignmentOp[EMODULO] = EMODASS;
+ AssignmentOp[EADDV] = MAXEXPR;
+ AssignmentOp[ESUBV] = MAXEXPR;
+ AssignmentOp[EADD] = EADDASS;
+ AssignmentOp[ESUB] = ESUBASS;
+ AssignmentOp[ESHL] = ESHLASS;
+ AssignmentOp[ESHR] = ESHRASS;
+ AssignmentOp[ELESS] = MAXEXPR;
+ AssignmentOp[EGREATER] = MAXEXPR;
+ AssignmentOp[ELESSEQU] = MAXEXPR;
+ AssignmentOp[EGREATEREQU] = MAXEXPR;
+ AssignmentOp[EEQU] = MAXEXPR;
+ AssignmentOp[ENOTEQU] = MAXEXPR;
+ AssignmentOp[EAND] = EANDASS;
+ AssignmentOp[EXOR] = EXORASS;
+ AssignmentOp[EOR] = EORASS;
+ AssignmentOp[ELAND] = MAXEXPR;
+ AssignmentOp[ELOR] = MAXEXPR;
+ AssignmentOp[EASS] = MAXEXPR;
+ AssignmentOp[EMULASS] = MAXEXPR;
+ AssignmentOp[EDIVASS] = MAXEXPR;
+ AssignmentOp[EMODASS] = MAXEXPR;
+ AssignmentOp[EADDASS] = MAXEXPR;
+ AssignmentOp[ESUBASS] = MAXEXPR;
+ AssignmentOp[ESHLASS] = MAXEXPR;
+ AssignmentOp[ESHRASS] = MAXEXPR;
+ AssignmentOp[EANDASS] = MAXEXPR;
+ AssignmentOp[EXORASS] = MAXEXPR;
+ AssignmentOp[EORASS] = MAXEXPR;
+ AssignmentOp[ECOMMA] = MAXEXPR;
+ AssignmentOp[EPMODULO] = MAXEXPR;
+ AssignmentOp[EROTL] = MAXEXPR;
+ AssignmentOp[EROTR] = MAXEXPR;
+ AssignmentOp[EBCLR] = MAXEXPR;
+ AssignmentOp[EBTST] = MAXEXPR;
+ AssignmentOp[EBSET] = MAXEXPR;
+ AssignmentOp[ETYPCON] = MAXEXPR;
+ AssignmentOp[EBITFIELD] = MAXEXPR;
+ AssignmentOp[EINTCONST] = MAXEXPR;
+ AssignmentOp[EFLOATCONST] = MAXEXPR;
+ AssignmentOp[ESTRINGCONST] = MAXEXPR;
+ AssignmentOp[ECOND] = MAXEXPR;
+ AssignmentOp[EFUNCCALL] = MAXEXPR;
+ AssignmentOp[EFUNCCALLP] = MAXEXPR;
+ AssignmentOp[EOBJREF] = MAXEXPR;
+ AssignmentOp[EMFPOINTER] = MAXEXPR;
+ AssignmentOp[ENULLCHECK] = MAXEXPR;
+ AssignmentOp[EPRECOMP] = MAXEXPR;
+ AssignmentOp[ETEMP] = MAXEXPR;
+ AssignmentOp[EARGOBJ] = MAXEXPR;
+ AssignmentOp[ELOCOBJ] = MAXEXPR;
+ AssignmentOp[ELABEL] = MAXEXPR;
+ AssignmentOp[ESETCONST] = MAXEXPR;
+ AssignmentOp[ENEWEXCEPTION] = MAXEXPR;
+ AssignmentOp[ENEWEXCEPTIONARRAY] = MAXEXPR;
+ AssignmentOp[EOBJLIST] = MAXEXPR;
+ AssignmentOp[EMEMBER] = MAXEXPR;
+ AssignmentOp[ETEMPLDEP] = MAXEXPR;
+ AssignmentOp[EINSTRUCTION] = MAXEXPR;
+ AssignmentOp[EDEFINE] = MAXEXPR;
+ AssignmentOp[EREUSE] = MAXEXPR;
+ AssignmentOp[EASSBLK] = MAXEXPR;
+ AssignmentOp[EVECTOR128CONST] = MAXEXPR;
+ AssignmentOp[ECONDASS] = MAXEXPR;
+}
+
+void IRO_InitializeComplementaryOpArray(void) {
+ int i;
+
+ for (i = 0; i < MAXEXPR; i++)
+ ComplementaryOp[i] = MAXEXPR;
+
+ ComplementaryOp[EPOSTINC] = EPOSTDEC;
+ ComplementaryOp[EPOSTDEC] = EPOSTINC;
+ ComplementaryOp[EPREINC] = EPREDEC;
+ ComplementaryOp[EPREDEC] = EPREINC;
+ ComplementaryOp[EINDIRECT] = MAXEXPR;
+ ComplementaryOp[EMONMIN] = EMONMIN;
+ ComplementaryOp[EBINNOT] = EBINNOT;
+ ComplementaryOp[ELOGNOT] = ELOGNOT;
+ ComplementaryOp[EFORCELOAD] = MAXEXPR;
+ ComplementaryOp[EMUL] = EDIV;
+ ComplementaryOp[EMULV] = MAXEXPR;
+ ComplementaryOp[EDIV] = EMUL;
+ ComplementaryOp[EMODULO] = MAXEXPR;
+ ComplementaryOp[EADDV] = ESUBV;
+ ComplementaryOp[ESUBV] = EADDV;
+ ComplementaryOp[EADD] = ESUB;
+ ComplementaryOp[ESUB] = EADD;
+ ComplementaryOp[ESHL] = ESHR;
+ ComplementaryOp[ESHR] = ESHL;
+ ComplementaryOp[ELESS] = EGREATER;
+ ComplementaryOp[EGREATER] = ELESS;
+ ComplementaryOp[ELESSEQU] = EGREATEREQU;
+ ComplementaryOp[EGREATEREQU] = ELESSEQU;
+ ComplementaryOp[EEQU] = ENOTEQU;
+ ComplementaryOp[ENOTEQU] = EEQU;
+ ComplementaryOp[EAND] = EOR;
+ ComplementaryOp[EXOR] = MAXEXPR;
+ ComplementaryOp[EOR] = EAND;
+ ComplementaryOp[ELAND] = ELOR;
+ ComplementaryOp[ELOR] = ELAND;
+ ComplementaryOp[EASS] = MAXEXPR;
+ ComplementaryOp[EMULASS] = EDIVASS;
+ ComplementaryOp[EDIVASS] = EMULASS;
+ ComplementaryOp[EMODASS] = MAXEXPR;
+ ComplementaryOp[EADDASS] = ESUBASS;
+ ComplementaryOp[ESUBASS] = EADDASS;
+ ComplementaryOp[ESHLASS] = ESHRASS;
+ ComplementaryOp[ESHRASS] = ESHLASS;
+ ComplementaryOp[EANDASS] = EORASS;
+ ComplementaryOp[EXORASS] = MAXEXPR;
+ ComplementaryOp[EORASS] = EANDASS;
+ ComplementaryOp[ECOMMA] = MAXEXPR;
+ ComplementaryOp[EPMODULO] = MAXEXPR;
+ ComplementaryOp[EROTL] = EROTR;
+ ComplementaryOp[EROTR] = EROTL;
+ ComplementaryOp[EBCLR] = MAXEXPR;
+ ComplementaryOp[EBTST] = MAXEXPR;
+ ComplementaryOp[EBSET] = MAXEXPR;
+ ComplementaryOp[ETYPCON] = MAXEXPR;
+ ComplementaryOp[EBITFIELD] = MAXEXPR;
+ ComplementaryOp[EINTCONST] = MAXEXPR;
+ ComplementaryOp[EFLOATCONST] = MAXEXPR;
+ ComplementaryOp[ESTRINGCONST] = MAXEXPR;
+ ComplementaryOp[ECOND] = MAXEXPR;
+ ComplementaryOp[EFUNCCALL] = MAXEXPR;
+ ComplementaryOp[EFUNCCALLP] = MAXEXPR;
+ ComplementaryOp[EOBJREF] = MAXEXPR;
+ ComplementaryOp[EMFPOINTER] = MAXEXPR;
+ ComplementaryOp[ENULLCHECK] = MAXEXPR;
+ ComplementaryOp[EPRECOMP] = MAXEXPR;
+ ComplementaryOp[ETEMP] = MAXEXPR;
+ ComplementaryOp[EARGOBJ] = MAXEXPR;
+ ComplementaryOp[ELOCOBJ] = MAXEXPR;
+ ComplementaryOp[ELABEL] = MAXEXPR;
+ ComplementaryOp[ESETCONST] = MAXEXPR;
+ ComplementaryOp[ENEWEXCEPTION] = MAXEXPR;
+ ComplementaryOp[ENEWEXCEPTIONARRAY] = MAXEXPR;
+ ComplementaryOp[EOBJLIST] = MAXEXPR;
+ ComplementaryOp[EMEMBER] = MAXEXPR;
+ ComplementaryOp[ETEMPLDEP] = MAXEXPR;
+ ComplementaryOp[EINSTRUCTION] = MAXEXPR;
+ ComplementaryOp[EDEFINE] = MAXEXPR;
+ ComplementaryOp[EREUSE] = MAXEXPR;
+ ComplementaryOp[EASSBLK] = MAXEXPR;
+ ComplementaryOp[EVECTOR128CONST] = MAXEXPR;
+ ComplementaryOp[ECONDASS] = MAXEXPR;
+}
+
+void IRO_InitializeComplementaryOpLogicalArray(void) {
+ int i;
+
+ for (i = 0; i < MAXEXPR; i++)
+ ComplementaryOpLogical[i] = MAXEXPR;
+
+ ComplementaryOpLogical[EPOSTINC] = MAXEXPR;
+ ComplementaryOpLogical[EPOSTDEC] = MAXEXPR;
+ ComplementaryOpLogical[EPREINC] = MAXEXPR;
+ ComplementaryOpLogical[EPREDEC] = MAXEXPR;
+ ComplementaryOpLogical[EINDIRECT] = MAXEXPR;
+ ComplementaryOpLogical[EMONMIN] = MAXEXPR;
+ ComplementaryOpLogical[EBINNOT] = MAXEXPR;
+ ComplementaryOpLogical[ELOGNOT] = ELOGNOT;
+ ComplementaryOpLogical[EFORCELOAD] = MAXEXPR;
+ ComplementaryOpLogical[EMUL] = MAXEXPR;
+ ComplementaryOpLogical[EMULV] = MAXEXPR;
+ ComplementaryOpLogical[EDIV] = MAXEXPR;
+ ComplementaryOpLogical[EMODULO] = MAXEXPR;
+ ComplementaryOpLogical[EADDV] = MAXEXPR;
+ ComplementaryOpLogical[ESUBV] = MAXEXPR;
+ ComplementaryOpLogical[EADD] = MAXEXPR;
+ ComplementaryOpLogical[ESUB] = MAXEXPR;
+ ComplementaryOpLogical[ESHL] = MAXEXPR;
+ ComplementaryOpLogical[ESHR] = MAXEXPR;
+ ComplementaryOpLogical[ELESS] = EGREATEREQU;
+ ComplementaryOpLogical[EGREATER] = ELESSEQU;
+ ComplementaryOpLogical[ELESSEQU] = EGREATER;
+ ComplementaryOpLogical[EGREATEREQU] = ELESS;
+ ComplementaryOpLogical[EEQU] = ENOTEQU;
+ ComplementaryOpLogical[ENOTEQU] = EEQU;
+ ComplementaryOpLogical[EAND] = MAXEXPR;
+ ComplementaryOpLogical[EXOR] = MAXEXPR;
+ ComplementaryOpLogical[EOR] = MAXEXPR;
+ ComplementaryOpLogical[ELAND] = ELOR;
+ ComplementaryOpLogical[ELOR] = ELAND;
+ ComplementaryOpLogical[EASS] = MAXEXPR;
+ ComplementaryOpLogical[EMULASS] = MAXEXPR;
+ ComplementaryOpLogical[EDIVASS] = MAXEXPR;
+ ComplementaryOpLogical[EMODASS] = MAXEXPR;
+ ComplementaryOpLogical[EADDASS] = MAXEXPR;
+ ComplementaryOpLogical[ESUBASS] = MAXEXPR;
+ ComplementaryOpLogical[ESHLASS] = MAXEXPR;
+ ComplementaryOpLogical[ESHRASS] = MAXEXPR;
+ ComplementaryOpLogical[EANDASS] = MAXEXPR;
+ ComplementaryOpLogical[EXORASS] = MAXEXPR;
+ ComplementaryOpLogical[EORASS] = MAXEXPR;
+ ComplementaryOpLogical[ECOMMA] = MAXEXPR;
+ ComplementaryOpLogical[EPMODULO] = MAXEXPR;
+ ComplementaryOpLogical[EROTL] = MAXEXPR;
+ ComplementaryOpLogical[EROTR] = MAXEXPR;
+ ComplementaryOpLogical[EBCLR] = MAXEXPR;
+ ComplementaryOpLogical[EBTST] = MAXEXPR;
+ ComplementaryOpLogical[EBSET] = MAXEXPR;
+ ComplementaryOpLogical[ETYPCON] = MAXEXPR;
+ ComplementaryOpLogical[EBITFIELD] = MAXEXPR;
+ ComplementaryOpLogical[EINTCONST] = MAXEXPR;
+ ComplementaryOpLogical[EFLOATCONST] = MAXEXPR;
+ ComplementaryOpLogical[ESTRINGCONST] = MAXEXPR;
+ ComplementaryOpLogical[ECOND] = MAXEXPR;
+ ComplementaryOpLogical[EFUNCCALL] = MAXEXPR;
+ ComplementaryOpLogical[EFUNCCALLP] = MAXEXPR;
+ ComplementaryOpLogical[EOBJREF] = MAXEXPR;
+ ComplementaryOpLogical[EMFPOINTER] = MAXEXPR;
+ ComplementaryOpLogical[ENULLCHECK] = MAXEXPR;
+ ComplementaryOpLogical[EPRECOMP] = MAXEXPR;
+ ComplementaryOpLogical[ETEMP] = MAXEXPR;
+ ComplementaryOpLogical[EARGOBJ] = MAXEXPR;
+ ComplementaryOpLogical[ELOCOBJ] = MAXEXPR;
+ ComplementaryOpLogical[ELABEL] = MAXEXPR;
+ ComplementaryOpLogical[ESETCONST] = MAXEXPR;
+ ComplementaryOpLogical[ENEWEXCEPTION] = MAXEXPR;
+ ComplementaryOpLogical[ENEWEXCEPTIONARRAY] = MAXEXPR;
+ ComplementaryOpLogical[EOBJLIST] = MAXEXPR;
+ ComplementaryOpLogical[EMEMBER] = MAXEXPR;
+ ComplementaryOpLogical[ETEMPLDEP] = MAXEXPR;
+ ComplementaryOpLogical[EINSTRUCTION] = MAXEXPR;
+ ComplementaryOpLogical[EDEFINE] = MAXEXPR;
+ ComplementaryOpLogical[EREUSE] = MAXEXPR;
+ ComplementaryOpLogical[EASSBLK] = MAXEXPR;
+ ComplementaryOpLogical[EVECTOR128CONST] = MAXEXPR;
+ ComplementaryOpLogical[ECONDASS] = MAXEXPR;
+}
+
+static void DoTransformations(IROLinear *nd) {
+ IROLinear *nd2;
+ IROLinear *nd3;
+ IROLinear *nd4;
+ IROLinear *nd5;
+ Type *newtype;
+ SInt32 value;
+
+ if (nd->type == IROLinearOp2Arg) {
+ switch (nd->nodetype) {
+ case EASS:
+ nd2 = nd->u.diadic.right;
+ if (
+ nd2->type == IROLinearOp2Arg &&
+ AssignmentOp[nd2->nodetype] < MAXEXPR &&
+ IRO_TypesEqual(nd->rtype, nd2->rtype) &&
+ IRO_IsVariable(nd3 = nd->u.diadic.left) &&
+ !(nd3->flags & IROLF_BitfieldIndirect) &&
+ IRO_ExprsSame(nd3, nd2->u.diadic.left)
+ )
+ {
+ nd->nodetype = AssignmentOp[nd2->nodetype];
+ nd->u.diadic.right = nd2->u.diadic.right;
+ IRO_NopOut(nd2->u.diadic.left);
+ nd2->type = IROLinearNop;
+
+ nd3->flags |= IROLF_Used;
+ nd3->u.diadic.left->flags |= IROLF_Used;
+ }
+ break;
+
+ case EMUL:
+ if (
+ IS_TYPE_INT(nd->rtype) &&
+ IRO_IsPow2(nd->u.diadic.right, &value)
+ )
+ {
+ nd->nodetype = ESHL;
+ CInt64_SetLong(&nd->u.diadic.right->u.node->data.intval, value);
+ }
+ break;
+
+ case EDIV:
+ if (
+ IS_TYPE_INT(nd->rtype) &&
+ IRO_IsPow2(nd->u.diadic.right, &value)
+ )
+ {
+ if (IRO_IsUnsignedType(nd->rtype)) {
+ nd->nodetype = ESHR;
+ CInt64_SetLong(&nd->u.diadic.right->u.node->data.intval, value);
+ } else if (
+ !IRO_IsUnsignedType(nd->rtype) &&
+ TYPE_INTEGRAL(nd->rtype)->integral != IT_BOOL &&
+ nd->u.diadic.left->nodetype == ETYPCON &&
+ IS_TYPE_INT(nd->u.diadic.left->u.monadic->rtype) &&
+ IRO_IsUnsignedType(nd->u.diadic.left->u.monadic->rtype) &&
+ nd->u.diadic.left->u.monadic->rtype->size < nd->u.diadic.left->rtype->size
+ )
+ {
+ nd->nodetype = ESHR;
+ CInt64_SetLong(&nd->u.diadic.right->u.node->data.intval, value);
+ if (nd->flags & IROLF_Reffed) {
+ IROLinear *copy = IRO_NewLinear(IROLinearOp1Arg);
+ memcpy(copy, nd, sizeof(IROLinear));
+ copy->type = IROLinearOp1Arg;
+ copy->nodetype = ETYPCON;
+ copy->index = IRO_NumLinear++;
+ copy->rtype = nd->rtype;
+ IRO_PasteAfter(copy, copy, nd);
+ IRO_LocateFather_Cut_And_Paste_Without_Nopping(nd, copy);
+ copy->u.monadic = nd;
+ nd->flags |= IROLF_Reffed;
+ }
+ nd->rtype = IRO_UnsignedType(nd->rtype);
+ newtype = IRO_UnsignedType(nd->u.diadic.right->rtype);
+ nd->u.diadic.right->u.node->rtype = newtype;
+ nd->u.diadic.right->rtype = newtype;
+ nd->u.diadic.left->rtype = IRO_UnsignedType(nd->u.diadic.left->rtype);
+ }
+ }
+ break;
+
+ case EMODULO:
+ if (
+ IS_TYPE_INT(nd->rtype) &&
+ IRO_IsUnsignedType(nd->rtype) &&
+ IRO_IsPow2(nd->u.diadic.right, &value)
+ )
+ {
+ nd->nodetype = EAND;
+ nd->u.diadic.right->u.node->data.intval = CInt64_Sub(nd->u.diadic.right->u.node->data.intval, cint64_one);
+ }
+ break;
+
+ case EEQU:
+ if (
+ (nd2 = IRO_LocateFather(nd)) &&
+ nd2->nodetype == ETYPCON &&
+ IS_TYPE_INT(nd2->rtype) &&
+ (nd3 = IRO_LocateFather(nd2)) &&
+ nd3->nodetype == ELOGNOT &&
+ (nd4 = IRO_LocateFather(nd3)) &&
+ nd4->nodetype == ETYPCON &&
+ IS_TYPE_INT(nd4->rtype) &&
+ (
+ ((nd5 = IRO_LocateFather(nd4)) && nd5->type == IROLinearIf) ||
+ nd5->type == IROLinearIfNot
+ )
+ )
+ {
+ IRO_LocateFather_Cut_And_Paste_Without_Nopping(nd4, nd);
+ nd->nodetype = ENOTEQU;
+ nd2->type = IROLinearNop;
+ nd3->type = IROLinearNop;
+ nd4->type = IROLinearNop;
+ }
+ break;
+ }
+ }
+}
+
+static void IRO_SwitchChildren(IROLinear *nd) {
+ IROLinear *tmp = nd->u.diadic.left;
+ nd->u.diadic.left = nd->u.diadic.right;
+ nd->u.diadic.right = tmp;
+}
+
+static void ReplaceExprWithConst(IROLinear *nd, CInt64 val) {
+ IRO_NopOut(nd);
+ nd->type = IROLinearOperand;
+ nd->nodetype = EINTCONST;
+ nd->u.node = IRO_NewENode(EINTCONST);
+ nd->u.node->data.intval = val;
+ nd->u.node->flags = nd->nodeflags;
+ nd->u.node->rtype = nd->rtype;
+
+ if (IS_TYPE_FLOAT(nd->rtype)) {
+ nd->u.node->type = EFLOATCONST;
+ nd->nodetype = EFLOATCONST;
+ nd->u.node->data.floatval = CMach_CalcFloatConvertFromInt(TYPE(&stsignedlong), val);
+ }
+}
+
+static void ReplaceExprWithLeftChild(IROLinear *nd) {
+ IROLinear *left = nd->u.diadic.left;
+ IROLinear *right = nd->u.diadic.right;
+
+ if (left->rtype == nd->rtype) {
+ IRO_LocateFather_Cut_And_Paste_Without_Nopping(nd, left);
+ left->flags = nd->flags;
+ left->nodeflags = nd->nodeflags;
+ nd->type = IROLinearNop;
+ IRO_NopOut(right);
+ } else {
+ nd->type = IROLinearOp1Arg;
+ nd->nodetype = ETYPCON;
+ nd->u.monadic = left;
+ IRO_NopOut(right);
+ }
+}
+
+static void ReplaceExprWithRightChild(IROLinear *nd) {
+ IROLinear *left = nd->u.diadic.left;
+ IROLinear *right = nd->u.diadic.right;
+
+ if (right->rtype == nd->rtype) {
+ IRO_LocateFather_Cut_And_Paste_Without_Nopping(nd, right);
+ right->flags = nd->flags;
+ right->nodeflags = nd->nodeflags;
+ nd->type = IROLinearNop;
+ IRO_NopOut(left);
+ } else {
+ nd->type = IROLinearOp1Arg;
+ nd->nodetype = ETYPCON;
+ nd->u.monadic = right;
+ IRO_NopOut(left);
+ }
+}
+
+static void ReplaceExprWithMonaminRight(IROLinear *nd) {
+ IROLinear *left = nd->u.diadic.left;
+ IROLinear *right = nd->u.diadic.right;
+
+ if (right->rtype == nd->rtype) {
+ nd->type = IROLinearOp1Arg;
+ nd->nodetype = EMONMIN;
+ nd->u.monadic = right;
+ IRO_NopOut(left);
+ } else {
+ IRO_NopOut(left);
+ left->type = IROLinearOp1Arg;
+ left->nodetype = ETYPCON;
+ left->expr = right->expr;
+ left->rtype = nd->rtype;
+ left->u.monadic = right;
+ nd->type = IROLinearOp1Arg;
+ nd->nodetype = EMONMIN;
+ nd->u.monadic = left;
+ }
+}
+
+static void ReplaceExprWithMonaminLeft(IROLinear *nd) {
+ IROLinear *left = nd->u.diadic.left;
+ IROLinear *right = nd->u.diadic.right;
+
+ if (left->rtype == nd->rtype) {
+ nd->type = IROLinearOp1Arg;
+ nd->nodetype = EMONMIN;
+ nd->u.monadic = left;
+ IRO_NopOut(right);
+ } else {
+ IRO_NopOut(right);
+ right->type = IROLinearOp1Arg;
+ right->nodetype = ETYPCON;
+ right->expr = left->expr;
+ right->rtype = nd->rtype;
+ right->u.monadic = left;
+ nd->type = IROLinearOp1Arg;
+ nd->nodetype = EMONMIN;
+ nd->u.monadic = right;
+ }
+}
+
+static void switchFatherLeftMonadic(IROLinear *nd) {
+ IROLinear *inner = nd->u.monadic;
+ IRO_LocateFather_Cut_And_Paste_Without_Nopping(nd, inner);
+ nd->u.monadic = inner->u.monadic;
+ inner->u.monadic = nd;
+ inner->rtype = nd->rtype;
+ inner->flags = nd->flags;
+ inner->nodeflags = nd->nodeflags;
+ IRO_CutAndPasteAfter(inner, inner, nd);
+}
+
+static void switchFatherLeft(IROLinear *nd, int isRight) {
+ IROLinear *a;
+ IROLinear *b;
+
+ a = nd->u.diadic.left;
+ IRO_LocateFather_Cut_And_Paste_Without_Nopping(nd, a);
+
+ if (isRight) {
+ nd->u.diadic.left = a->u.diadic.left;
+ a->u.diadic.left = nd;
+ b = a->u.diadic.right;
+ } else {
+ nd->u.diadic.left = a->u.diadic.right;
+ a->u.diadic.right = nd;
+ b = a->u.diadic.left;
+ }
+
+ a->rtype = nd->rtype;
+ a->flags = nd->flags;
+ a->nodeflags = nd->nodeflags;
+ IRO_CutAndPasteAfter(a, a, nd);
+ IRO_CutAndPasteAfter(IRO_FindFirst(b), b, nd);
+}
+
+static void PickCommonsubAtLeftLeft(IROLinear *nd) {
+ switchFatherLeft(nd, 0);
+ ReplaceExprWithRightChild(nd->u.diadic.right);
+}
+
+static void PickCommonsubAtRightLeft(IROLinear *nd) {
+ switchFatherLeft(nd, 1);
+ ReplaceExprWithRightChild(nd->u.diadic.right);
+}
+
+static void PickCommonsubAtLeftRight(IROLinear *nd) {
+ switchFatherLeft(nd, 0);
+ ReplaceExprWithLeftChild(nd->u.diadic.right);
+}
+
+static void PickCommonsubAtRightRight(IROLinear *nd) {
+ switchFatherLeft(nd, 1);
+ ReplaceExprWithLeftChild(nd->u.diadic.right);
+}
+
+static void DoTransformations11(IROLinear *nd) {
+ IROLinear *left;
+ IROLinear *right;
+ int changed;
+ int compare;
+ Type *type;
+ SInt32 tmp1;
+ SInt32 tmp2;
+ CInt64 val;
+
+ if (nd->type == IROLinearOp2Arg) {
+ left = nd->u.diadic.left;
+ right = nd->u.diadic.right;
+ if (IS_TYPE_FLOAT(nd->rtype) || IS_TYPE_FLOAT(left->rtype) || IS_TYPE_FLOAT(right->rtype))
+ return;
+
+ changed = 0;
+ if (!IRO_HasSideEffect(left) && !IRO_HasSideEffect(right)) {
+ if (IRO_IsIntConstant(right) || IRO_IsFloatConstant(right)) {
+ if (IRO_IsConstantZero(right)) {
+ switch (nd->nodetype) {
+ case EADDV:
+ case ESUBV:
+ case EADD:
+ case ESUB:
+ case ESHL:
+ case ESHR:
+ case EXOR:
+ case EOR:
+ case ELOR:
+ case EADDASS:
+ case ESUBASS:
+ case ESHLASS:
+ case ESHRASS:
+ case EXORASS:
+ case EORASS:
+ ReplaceExprWithLeftChild(nd);
+ changed = 1;
+ break;
+ case EMUL:
+ case EAND:
+ case ELAND:
+ ReplaceExprWithConst(nd, cint64_zero);
+ changed = 1;
+ break;
+ case EMULASS:
+ case EANDASS:
+ nd->nodetype = EASS;
+ nd->u.diadic.right->rtype = nd->rtype;
+ nd->u.diadic.right->u.node->rtype = nd->rtype;
+ changed = 1;
+ break;
+ case EDIV:
+ case EMODULO:
+ case EDIVASS:
+ case EMODASS:
+ if (nd->stmt->sourceoffset) {
+ TStreamElement *token = CPrep_CurStreamElement();
+ token->tokenoffset = nd->stmt->sourceoffset;
+ CError_SetErrorToken(token);
+ }
+ CError_Warning(CErrorStr139);
+ break;
+ }
+ } else if (nd->nodetype == ELAND) {
+ ReplaceExprWithLeftChild(nd);
+ changed = 1;
+ } else if (nd->nodetype == ELOR) {
+ ReplaceExprWithConst(nd, cint64_one);
+ changed = 1;
+ } else if (nd->nodetype == ESHL || nd->nodetype == ESHR || nd->nodetype == ESHLASS || nd->nodetype == ESHRASS) {
+ type = nd->rtype;
+ tmp1 = type->size * 8;
+ if (left->type == IROLinearOp1Arg && left->nodetype == ETYPCON) {
+ type = left->u.monadic->rtype;
+ if (
+ left->u.monadic->type == IROLinearOp1Arg &&
+ left->u.monadic->nodetype == EINDIRECT &&
+ left->u.monadic->u.monadic->type == IROLinearOp1Arg &&
+ left->u.monadic->u.monadic->nodetype == EBITFIELD &&
+ IS_TYPE_BITFIELD(left->u.monadic->u.monadic->rtype)
+ )
+ tmp2 = TYPE_BITFIELD(left->u.monadic->u.monadic->rtype)->unkB;
+ else
+ tmp2 = type->size * 8;
+ } else {
+ tmp2 = tmp1;
+ }
+
+ switch (nd->nodetype) {
+ case ESHL:
+ case ESHLASS:
+ CInt64_SetLong(&val, tmp1);
+ if (IRO_IsUnsignedType(type))
+ compare = CInt64_GreaterEqualU(right->u.node->data.intval, val);
+ else
+ compare = CInt64_GreaterEqual(right->u.node->data.intval, val);
+ break;
+ case ESHR:
+ case ESHRASS:
+ CInt64_SetLong(&val, tmp2);
+ compare = IRO_IsUnsignedType(type) && CInt64_GreaterEqualU(right->u.node->data.intval, val);
+ break;
+ }
+
+ if (compare) {
+ switch (nd->nodetype) {
+ case ESHL:
+ case ESHR:
+ ReplaceExprWithConst(nd, cint64_zero);
+ break;
+ case ESHLASS:
+ case ESHRASS:
+ nd->nodetype = EASS;
+ ReplaceExprWithConst(right, cint64_zero);
+ break;
+ }
+ changed = 1;
+ }
+ } else if (IRO_IsConstantOne(right)) {
+ switch (nd->nodetype) {
+ case EMUL:
+ case EMULV:
+ case EDIV:
+ case EMULASS:
+ case EDIVASS:
+ ReplaceExprWithLeftChild(nd);
+ changed = 1;
+ break;
+ case EMODULO:
+ ReplaceExprWithConst(nd, cint64_zero);
+ changed = 1;
+ break;
+ case EMODASS:
+ nd->nodetype = EASS;
+ ReplaceExprWithConst(right, cint64_zero);
+ nd->u.diadic.right->rtype = nd->rtype;
+ nd->u.diadic.right->u.node->rtype = nd->rtype;
+ changed = 1;
+ break;
+ }
+ } else if (IRO_IsConstantNegativeOne(right)) {
+ switch (nd->nodetype) {
+ case EMUL:
+ case EMULV:
+ case EDIV:
+ ReplaceExprWithMonaminLeft(nd);
+ changed = 1;
+ break;
+ case EMODULO:
+ ReplaceExprWithConst(nd, cint64_zero);
+ changed = 1;
+ break;
+ case EMODASS:
+ nd->nodetype = EASS;
+ ReplaceExprWithConst(right, cint64_zero);
+ nd->u.diadic.right->rtype = nd->rtype;
+ nd->u.diadic.right->u.node->rtype = nd->rtype;
+ changed = 1;
+ break;
+ }
+ }
+ }
+
+ if (!changed && (IRO_IsIntConstant(left) || IRO_IsFloatConstant(left))) {
+ if (IRO_IsConstantZero(left)) {
+ switch (nd->nodetype) {
+ case EADDV:
+ case EADD:
+ case EXOR:
+ case EOR:
+ case ELOR:
+ ReplaceExprWithRightChild(nd);
+ break;
+ case EMUL:
+ case ESHL:
+ case ESHR:
+ case EAND:
+ case ELAND:
+ ReplaceExprWithConst(nd, cint64_zero);
+ break;
+ case ESUBV:
+ case ESUB:
+ ReplaceExprWithMonaminRight(nd);
+ break;
+ }
+ } else if (nd->nodetype == ELAND) {
+ ReplaceExprWithRightChild(nd);
+ } else if (nd->nodetype == ELOR) {
+ ReplaceExprWithConst(nd, cint64_one);
+ } else if (IRO_IsConstantOne(left)) {
+ switch (nd->nodetype) {
+ case EMUL:
+ case EMULV:
+ ReplaceExprWithRightChild(nd);
+ break;
+ }
+ } else if (IRO_IsConstantNegativeOne(left)) {
+ switch (nd->nodetype) {
+ case EMUL:
+ case EMULV:
+ ReplaceExprWithMonaminRight(nd);
+ break;
+ }
+ }
+ }
+ }
+ }
+}
+
+static void DoTransformations12(IROLinear *nd) {
+ IROLinear *left;
+ IROLinear *right;
+
+ if (nd->type == IROLinearOp2Arg) {
+ left = nd->u.diadic.left;
+ right = nd->u.diadic.right;
+ if (IS_TYPE_FLOAT(nd->rtype) || IS_TYPE_FLOAT(left->rtype) || IS_TYPE_FLOAT(right->rtype))
+ return;
+
+ if (IRO_ExprsSameSemantically(left, right) && !IRO_HasSideEffect(left)) {
+ switch (nd->nodetype) {
+ case ESUBV:
+ case ESUB:
+ case ELESS:
+ case EGREATER:
+ case ENOTEQU:
+ case EXOR:
+ ReplaceExprWithConst(nd, cint64_zero);
+ break;
+ case ELESSEQU:
+ case EGREATEREQU:
+ case EEQU:
+ ReplaceExprWithConst(nd, cint64_one);
+ break;
+ case EAND:
+ case EOR:
+ case ELAND:
+ case ELOR:
+ case EASS:
+ case EANDASS:
+ case EORASS:
+ ReplaceExprWithLeftChild(nd);
+ break;
+ case ESUBASS:
+ case EXORASS:
+ nd->nodetype = EASS;
+ ReplaceExprWithConst(right, cint64_zero);
+ break;
+ }
+ }
+ }
+}
+
+static void DoTransformations13(IROLinear *nd) {
+ IROLinear *left;
+ IROLinear *right;
+ IROLinear *left2;
+ IROLinear *right2;
+ IROListNode *tmp;
+ IROListNode *leftlist;
+ IROListNode *rightlist;
+
+ if (nd->type == IROLinearOp2Arg) {
+ left = nd->u.diadic.left;
+ right = nd->u.diadic.right;
+
+ if (
+ !IRO_HasSideEffect(left) &&
+ !IRO_HasSideEffect(right) &&
+ (nd->nodetype == EEQU || nd->nodetype == ENOTEQU) &&
+ PointerAnalysis_IsLinearNodePointerExprDefinite(FunctionName, left) &&
+ PointerAnalysis_IsLinearNodePointerExprDefinite(FunctionName, right)
+ )
+ {
+ leftlist = NULL;
+ PointerAnalysis_LookupLinearNodePointerExpr(FunctionName, left, &leftlist);
+ if (leftlist) {
+ if (leftlist->list.head && leftlist->list.tail && !leftlist->nextList) {
+ rightlist = NULL;
+ PointerAnalysis_LookupLinearNodePointerExpr(FunctionName, right, &rightlist);
+ if (rightlist) {
+ if (rightlist->list.head && rightlist->list.tail && !rightlist->nextList) {
+ left2 = leftlist->list.tail;
+ right2 = rightlist->list.tail;
+ if (IRO_ExprsSameSemantically(left2, right2)) {
+ ReplaceExprWithConst(nd, (nd->nodetype == EEQU) ? cint64_one : cint64_zero);
+ } else if (left2->type == right2->type && IRO_TypesEqual(left2->rtype, right2->rtype)) {
+ ReplaceExprWithConst(nd, (nd->nodetype == EEQU) ? cint64_zero : cint64_one);
+ }
+ }
+
+ while (rightlist) {
+ tmp = rightlist->nextList;
+ IRO_free(rightlist);
+ rightlist = tmp;
+ }
+ }
+ }
+
+ while (leftlist) {
+ tmp = leftlist->nextList;
+ IRO_free(leftlist);
+ leftlist = tmp;
+ }
+ }
+ }
+ }
+}
+
+static void DoTransformations21(IROLinear *nd) {
+ IROLinear *left;
+ IROLinear *right;
+ Boolean changed;
+
+ if (nd->type == IROLinearOp2Arg) {
+ left = nd->u.diadic.left;
+ right = nd->u.diadic.right;
+
+ if (left->type == IROLinearOp1Arg && right->type == IROLinearOp1Arg && left->nodetype == right->nodetype) {
+ switch (left->nodetype) {
+ case EMONMIN:
+ case EBINNOT:
+ case ELOGNOT:
+ changed = 0;
+ switch (nd->nodetype) {
+ case EXOR:
+ if (left->nodetype == EBINNOT)
+ goto collapse;
+ break;
+ case ELESS:
+ case EGREATER:
+ case ELESSEQU:
+ case EGREATEREQU:
+ if (left->nodetype == EMONMIN) {
+ nd->nodetype = ComplementaryOp[nd->nodetype];
+ goto collapse;
+ }
+ break;
+ case EMUL:
+ case EDIV:
+ if (left->nodetype == EMONMIN)
+ goto collapse;
+ break;
+ case EEQU:
+ case ENOTEQU:
+ if (left->nodetype != ELOGNOT) {
+ collapse:
+ nd->u.diadic.left = left->u.monadic;
+ nd->u.diadic.right = right->u.monadic;
+ left->type = right->type = IROLinearNop;
+ changed = 1;
+ }
+ break;
+ case ELAND:
+ case ELOR:
+ if (left->nodetype == ELOGNOT) {
+ nd->nodetype = ComplementaryOp[nd->nodetype];
+ goto switchfather;
+ }
+ break;
+ case EAND:
+ case EOR:
+ if (
+ !IS_TYPE_FLOAT(nd->rtype) &&
+ !IS_TYPE_FLOAT(left->rtype) &&
+ !IS_TYPE_FLOAT(right->rtype) &&
+ left->nodetype != EMONMIN
+ )
+ {
+ nd->nodetype = ComplementaryOp[nd->nodetype];
+ goto switchfather;
+ }
+ break;
+ case EADD:
+ case ESUB:
+ if (
+ !IS_TYPE_FLOAT(nd->rtype) &&
+ !IS_TYPE_FLOAT(left->rtype) &&
+ !IS_TYPE_FLOAT(right->rtype) &&
+ left->nodetype == EMONMIN
+ )
+ {
+ switchfather:
+ switchFatherLeftMonadic(nd);
+ nd->u.diadic.right = right->u.monadic;
+ right->type = IROLinearNop;
+ changed = 1;
+ }
+ break;
+ }
+
+ if (changed) {
+ DoTransformations(nd);
+ DoTransformations11(nd);
+ DoTransformations12(nd);
+ DoTransformations13(nd);
+ }
+ break;
+ }
+ }
+ }
+}
+
+static void DoTransformations22(IROLinear *nd) {
+ IROLinear *left;
+ IROLinear *right;
+ IROLinear *ndtmp;
+
+ if (nd->type == IROLinearOp2Arg) {
+ left = nd->u.diadic.left;
+ right = nd->u.diadic.right;
+ if (IS_TYPE_FLOAT(nd->rtype) || IS_TYPE_FLOAT(left->rtype) || IS_TYPE_FLOAT(right->rtype))
+ return;
+
+ if (!IRO_HasSideEffect(left) && !IRO_HasSideEffect(right)) {
+ if (left->type == IROLinearOp1Arg && left->nodetype == EMONMIN) {
+ switch (nd->nodetype) {
+ case ESUB:
+ case ESUBV:
+ nd->nodetype = ComplementaryOp[nd->nodetype];
+ switchFatherLeftMonadic(nd);
+ break;
+
+ case EADD:
+ case EADDV:
+ nd->nodetype = ComplementaryOp[nd->nodetype];
+ nd->u.diadic.left = right;
+ nd->u.diadic.right = left->u.monadic;
+ left->type = IROLinearNop;
+ DoTransformations(nd);
+ DoTransformations12(nd);
+ DoTransformations21(nd);
+ break;
+
+ case EDIV:
+ if (IRO_ExprsSameSemantically(left->u.monadic, right))
+ ReplaceExprWithConst(nd, cint64_negone);
+ break;
+ }
+ } else {
+ ndtmp = NULL;
+ if (left->type == IROLinearOp1Arg && IRO_ExprsSameSemantically(left->u.monadic, right))
+ ndtmp = left;
+ else if (right->type == IROLinearOp1Arg && IRO_ExprsSameSemantically(left, right->u.monadic))
+ ndtmp = right;
+
+ if (ndtmp) {
+ switch (nd->nodetype) {
+ case EAND:
+ if (ndtmp->nodetype == EBINNOT || ndtmp->nodetype == ELOGNOT)
+ ReplaceExprWithConst(nd, cint64_zero);
+ break;
+
+ case EANDASS:
+ if (ndtmp->nodetype == EBINNOT || ndtmp->nodetype == ELOGNOT) {
+ nd->nodetype = EASS;
+ ReplaceExprWithConst(right, cint64_zero);
+ nd->u.diadic.right->rtype = nd->rtype;
+ nd->u.diadic.right->u.node->rtype = nd->rtype;
+ }
+ break;
+
+ case EXOR:
+ case EOR:
+ if (ndtmp->nodetype == EBINNOT) {
+ ReplaceExprWithConst(nd, cint64_zero);
+ nd->u.node->data.intval = CInt64_Inv(nd->u.node->data.intval);
+ }
+ break;
+
+ case EXORASS:
+ case EORASS:
+ if (ndtmp->nodetype == EBINNOT) {
+ nd->nodetype = EASS;
+ ReplaceExprWithConst(right, cint64_zero);
+ right->u.node->data.intval = CInt64_Inv(right->u.node->data.intval);
+ nd->u.diadic.right->rtype = nd->rtype;
+ nd->u.diadic.right->u.node->rtype = nd->rtype;
+ }
+ break;
+
+ case ELOR:
+ if (ndtmp->nodetype == EBINNOT || ndtmp->nodetype == ELOGNOT)
+ ReplaceExprWithConst(nd, cint64_one);
+ break;
+
+ case ELAND:
+ if (ndtmp->nodetype == ELOGNOT)
+ ReplaceExprWithConst(nd, cint64_zero);
+ break;
+
+ case EDIV:
+ if (ndtmp->nodetype == EMONMIN)
+ ReplaceExprWithConst(nd, cint64_negone);
+ break;
+
+ case EDIVASS:
+ if (ndtmp->nodetype == EMONMIN) {
+ nd->nodetype = EASS;
+ ReplaceExprWithConst(right, cint64_negone);
+ nd->u.diadic.right->rtype = nd->rtype;
+ nd->u.diadic.right->u.node->rtype = nd->rtype;
+ }
+ break;
+ }
+ }
+ }
+ }
+ }
+}
+
+static void DoTransformations23(IROLinear *nd) {
+ Boolean changed;
+ Boolean isCompare;
+ UInt8 which;
+ IROLinear *left;
+ IROLinear *right;
+ CInt64 size;
+ CInt64 val;
+
+ if (nd->type == IROLinearOp2Arg && !IRO_HasSideEffect(nd)) {
+ left = nd->u.diadic.left;
+ right = nd->u.diadic.right;
+ if (IS_TYPE_FLOAT(nd->rtype) || IS_TYPE_FLOAT(left->rtype) || IS_TYPE_FLOAT(right->rtype))
+ return;
+
+ isCompare = 0;
+ changed = 0;
+ which = 0;
+
+ switch (nd->nodetype) {
+ case ELESS:
+ case EGREATER:
+ case ELESSEQU:
+ case EGREATEREQU:
+ isCompare = 1;
+ case EADDV:
+ case EADD:
+ case EEQU:
+ case ENOTEQU:
+ case EAND:
+ case EOR:
+ if (left->type == IROLinearOp2Arg) {
+ if (IRO_ExprsSameSemantically(right, left->u.diadic.left))
+ which = 1;
+ else if (IRO_ExprsSameSemantically(right, left->u.diadic.right))
+ which = 2;
+
+ if (which) {
+ if (isCompare)
+ nd->nodetype = ComplementaryOp[nd->nodetype];
+ IRO_SwitchChildren(nd);
+ left = nd->u.diadic.left;
+ right = nd->u.diadic.right;
+ break;
+ }
+ }
+ case ESUBV:
+ case ESUB:
+ case EADDASS:
+ case ESUBASS:
+ case EANDASS:
+ case EORASS:
+ if (right->type == IROLinearOp2Arg) {
+ if (IRO_ExprsSameSemantically(left, right->u.diadic.left))
+ which = 1;
+ else if (IRO_ExprsSameSemantically(left, right->u.diadic.right))
+ which = 2;
+ }
+ break;
+
+ default:
+ goto done;
+ }
+
+ if (which) {
+ switch (right->nodetype) {
+ case EAND:
+ case EOR:
+ if (which == 2)
+ IRO_SwitchChildren(right);
+
+ if (
+ nd->nodetype == right->nodetype ||
+ (nd->nodetype == EANDASS && right->nodetype == EAND) ||
+ (nd->nodetype == EORASS && right->nodetype == EOR)
+ )
+ {
+ ReplaceExprWithRightChild(right);
+ changed = 1;
+ }
+ else if (
+ nd->nodetype == ComplementaryOp[right->nodetype] ||
+ (nd->nodetype == EANDASS && right->nodetype == EOR) ||
+ (nd->nodetype == EORASS && right->nodetype == EAND)
+ )
+ {
+ ReplaceExprWithLeftChild(nd);
+ }
+ break;
+
+ case EADD:
+ if (which == 2)
+ IRO_SwitchChildren(right);
+
+ switch (nd->nodetype) {
+ case EEQU:
+ case ENOTEQU:
+ ReplaceExprWithConst(left, cint64_zero);
+ ReplaceExprWithRightChild(right);
+ IRO_SwitchChildren(nd);
+ if (isCompare)
+ nd->nodetype = ComplementaryOp[nd->nodetype];
+ changed = 1;
+ break;
+
+ case ESUB:
+ case ESUBV:
+ ReplaceExprWithRightChild(right);
+ ReplaceExprWithMonaminRight(nd);
+ changed = 1;
+ break;
+
+ case ESUBASS:
+ ReplaceExprWithRightChild(right);
+ changed = 1;
+ break;
+ }
+ break;
+
+ case ESUB:
+ switch (nd->nodetype) {
+ case EEQU:
+ case ENOTEQU:
+ if (which == 1) {
+ ReplaceExprWithConst(left, cint64_zero);
+ ReplaceExprWithRightChild(right);
+ IRO_SwitchChildren(nd);
+ }
+ break;
+ case EADD:
+ case EADDV:
+ if (which == 2) {
+ ReplaceExprWithLeftChild(right);
+ ReplaceExprWithRightChild(nd);
+ }
+ break;
+ case ESUB:
+ case ESUBV:
+ if (which == 1) {
+ ReplaceExprWithRightChild(right);
+ ReplaceExprWithRightChild(nd);
+ }
+ break;
+ case EADDASS:
+ if (which == 2) {
+ nd->nodetype = EASS;
+ ReplaceExprWithLeftChild(right);
+ changed = 1;
+ }
+ break;
+ case ESUBASS:
+ if (which == 1) {
+ nd->nodetype = EASS;
+ ReplaceExprWithRightChild(right);
+ changed = 1;
+ }
+ break;
+ }
+ break;
+ }
+ }
+
+ done:
+ if (!changed) {
+ switch (nd->nodetype) {
+ case ESUB:
+ case ESUBV:
+ which = 0;
+ if (left->type == IROLinearOp2Arg) {
+ if (IRO_ExprsSameSemantically(right, left->u.diadic.left))
+ which = 1;
+ else if (IRO_ExprsSameSemantically(right, left->u.diadic.right))
+ which = 2;
+ }
+
+ if (which == 1) {
+ if (left->nodetype == ESUB) {
+ ReplaceExprWithMonaminRight(left);
+ ReplaceExprWithLeftChild(nd);
+ } else if (left->nodetype == EADD) {
+ ReplaceExprWithRightChild(left);
+ ReplaceExprWithLeftChild(nd);
+ }
+ } else if (which == 2) {
+ if (left->nodetype == EADD) {
+ ReplaceExprWithLeftChild(left);
+ ReplaceExprWithLeftChild(nd);
+ }
+ }
+ break;
+ }
+
+ switch (nd->nodetype) {
+ case ESHL:
+ case ESHR:
+ case ESHLASS:
+ case ESHRASS:
+ which = 0;
+ if (left->type == IROLinearOp2Arg) {
+ if (left->nodetype == ComplementaryOp[nd->nodetype] || left->nodetype == AssignmentOp[ComplementaryOp[nd->nodetype]]) {
+ if (IRO_IsIntConstant(right) && IRO_ExprsSameSemantically(right, left->u.diadic.right))
+ which = 2;
+ }
+ }
+
+ if (which == 2) {
+ val = right->u.node->data.intval;
+ if (left->nodetype == ESHR || left->nodetype == ESHRASS) {
+ ReplaceExprWithLeftChild(left);
+ nd->nodetype = (nd->nodetype == ESHL) ? EAND : EANDASS;
+ right->u.node->data.intval = CInt64_Shl(cint64_negone, val);
+ changed = 1;
+ } else if (IRO_IsUnsignedType(nd->rtype)) {
+ ReplaceExprWithLeftChild(left);
+ nd->nodetype = (nd->nodetype == ESHR) ? EAND : EANDASS;
+ if (nd->rtype->size < 8) {
+ CInt64_SetLong(&size, 64 - 8 * nd->rtype->size);
+ val = CInt64_Add(val, size);
+ }
+ right->u.node->data.intval = CInt64_ShrU(cint64_negone, val);
+ changed = 1;
+ }
+ }
+ break;
+ }
+ }
+
+ if (changed) {
+ DoTransformations(nd);
+ DoTransformations11(nd);
+ DoTransformations12(nd);
+ DoTransformations13(nd);
+ DoTransformations21(nd);
+ DoTransformations22(nd);
+ DoTransformations23(nd);
+ }
+ }
+}
+
+static void DoTransformations24(IROLinear *nd) {
+ IROLinear *left;
+ IROLinear *right;
+ UInt8 changed;
+
+ if (nd->type == IROLinearOp2Arg) {
+ left = nd->u.diadic.left;
+ right = nd->u.diadic.right;
+ if (IS_TYPE_FLOAT(nd->rtype) || IS_TYPE_FLOAT(left->rtype) || IS_TYPE_FLOAT(right->rtype))
+ return;
+
+ if (left->type == IROLinearOp2Arg && right->type == IROLinearOp2Arg && !IRO_HasSideEffect(nd)) {
+ changed = 0;
+
+ if (IRO_ExprsSameSemantically(left->u.diadic.left, right->u.diadic.left)) {
+ if (left->nodetype == right->nodetype) {
+ switch (left->nodetype) {
+ case EADD:
+ if (nd->nodetype == ComplementaryOp[left->nodetype]) {
+ ReplaceExprWithRightChild(left);
+ ReplaceExprWithRightChild(right);
+ changed = 1;
+ }
+ break;
+ case ESUB:
+ if (nd->nodetype == ESUB || nd->nodetype == ESUBV) {
+ ReplaceExprWithRightChild(left);
+ ReplaceExprWithRightChild(right);
+ IRO_SwitchChildren(nd);
+ changed = 1;
+ }
+ break;
+ case EMUL:
+ switch (nd->nodetype) {
+ case EADD:
+ case ESUB:
+ PickCommonsubAtLeftLeft(nd);
+ changed = 3;
+ break;
+ }
+ break;
+ case EAND:
+ if (nd->nodetype == EXOR) {
+ PickCommonsubAtLeftLeft(nd);
+ changed = 3;
+ break;
+ }
+ case EOR:
+ if (nd->nodetype == left->nodetype) {
+ ReplaceExprWithRightChild(left);
+ changed = 1;
+ } else if (nd->nodetype == ComplementaryOp[left->nodetype]) {
+ PickCommonsubAtLeftLeft(nd);
+ changed = 3;
+ }
+ break;
+ }
+ } else if (left->nodetype == ComplementaryOp[right->nodetype]) {
+ switch (nd->nodetype) {
+ case ESUB:
+ case ESUBV:
+ switch (left->nodetype) {
+ case EADD:
+ nd->nodetype = ComplementaryOp[nd->nodetype];
+ ReplaceExprWithRightChild(left);
+ ReplaceExprWithRightChild(right);
+ changed = 1;
+ break;
+ case ESUB:
+ ReplaceExprWithMonaminRight(left);
+ ReplaceExprWithRightChild(right);
+ changed = 1;
+ break;
+ }
+ break;
+
+ case EAND:
+ case EOR:
+ if (left->nodetype == nd->nodetype)
+ ReplaceExprWithLeftChild(nd);
+ else if (right->nodetype == nd->nodetype)
+ ReplaceExprWithRightChild(nd);
+ break;
+ }
+ }
+ } else if (IRO_ExprsSameSemantically(left->u.diadic.right, right->u.diadic.left)) {
+ if (left->nodetype == right->nodetype) {
+ switch (left->nodetype) {
+ case EADD:
+ if (nd->nodetype == ComplementaryOp[left->nodetype]) {
+ ReplaceExprWithLeftChild(left);
+ ReplaceExprWithRightChild(right);
+ changed = 1;
+ }
+ break;
+ case EMUL:
+ switch (nd->nodetype) {
+ case EADD:
+ case ESUB:
+ PickCommonsubAtRightLeft(nd);
+ changed = 3;
+ break;
+ }
+ break;
+ case EAND:
+ if (nd->nodetype == EXOR) {
+ PickCommonsubAtRightLeft(nd);
+ changed = 3;
+ break;
+ }
+ case EOR:
+ if (nd->nodetype == left->nodetype) {
+ ReplaceExprWithLeftChild(left);
+ changed = 1;
+ } else if (nd->nodetype == ComplementaryOp[left->nodetype]) {
+ PickCommonsubAtRightLeft(nd);
+ changed = 3;
+ }
+ break;
+ }
+ } else if (left->nodetype == ComplementaryOp[right->nodetype]) {
+ switch (nd->nodetype) {
+ case ESUB:
+ case ESUBV:
+ if (left->nodetype == EADD) {
+ nd->nodetype = ComplementaryOp[nd->nodetype];
+ ReplaceExprWithLeftChild(left);
+ ReplaceExprWithRightChild(right);
+ changed = 1;
+ }
+ break;
+
+ case EADD:
+ case EADDV:
+ if (left->nodetype == ESUB) {
+ ReplaceExprWithLeftChild(left);
+ ReplaceExprWithRightChild(right);
+ changed = 1;
+ }
+ break;
+
+ case EAND:
+ case EOR:
+ if (left->nodetype == nd->nodetype)
+ ReplaceExprWithLeftChild(nd);
+ else if (right->nodetype == nd->nodetype)
+ ReplaceExprWithRightChild(nd);
+ break;
+ }
+ }
+ } else if (IRO_ExprsSameSemantically(left->u.diadic.left, right->u.diadic.right)) {
+ if (left->nodetype == right->nodetype) {
+ switch (left->nodetype) {
+ case EADD:
+ if (nd->nodetype == ComplementaryOp[left->nodetype]) {
+ ReplaceExprWithRightChild(left);
+ ReplaceExprWithLeftChild(right);
+ changed = 1;
+ }
+ break;
+ case ESUB:
+ switch (nd->nodetype) {
+ case EADDV:
+ case EADD:
+ nd->nodetype = ComplementaryOp[nd->nodetype];
+ ReplaceExprWithRightChild(left);
+ ReplaceExprWithLeftChild(right);
+ IRO_SwitchChildren(nd);
+ changed = 1;
+ break;
+ }
+ break;
+ case EMUL:
+ switch (nd->nodetype) {
+ case EADD:
+ case ESUB:
+ PickCommonsubAtLeftRight(nd);
+ changed = 2;
+ break;
+ }
+ break;
+ case EAND:
+ if (nd->nodetype == EXOR) {
+ PickCommonsubAtLeftRight(nd);
+ changed = 2;
+ break;
+ }
+ case EOR:
+ if (nd->nodetype == left->nodetype) {
+ ReplaceExprWithRightChild(left);
+ changed = 1;
+ } else if (nd->nodetype == ComplementaryOp[left->nodetype]) {
+ PickCommonsubAtLeftRight(nd);
+ changed = 2;
+ }
+ break;
+ }
+ } else if (left->nodetype == ComplementaryOp[right->nodetype]) {
+ switch (nd->nodetype) {
+ case EADD:
+ case EADDV:
+ if (left->nodetype == EADD) {
+ ReplaceExprWithRightChild(left);
+ ReplaceExprWithLeftChild(right);
+ changed = 1;
+ }
+ break;
+
+ case ESUB:
+ case ESUBV:
+ if (left->nodetype == ESUB) {
+ ReplaceExprWithMonaminRight(left);
+ ReplaceExprWithRightChild(right);
+ changed = 1;
+ }
+ break;
+
+ case EAND:
+ case EOR:
+ if (left->nodetype == nd->nodetype)
+ ReplaceExprWithLeftChild(nd);
+ else if (right->nodetype == nd->nodetype)
+ ReplaceExprWithRightChild(nd);
+ break;
+ }
+ }
+ } else if (IRO_ExprsSameSemantically(left->u.diadic.right, right->u.diadic.right)) {
+ if (left->nodetype == right->nodetype) {
+ switch (nd->nodetype) {
+ case ESUB:
+ switch (left->nodetype) {
+ case EADD:
+ case ESUB:
+ ReplaceExprWithLeftChild(left);
+ ReplaceExprWithLeftChild(right);
+ changed = 1;
+ }
+ case EADD:
+ switch (left->nodetype) {
+ case EMUL:
+ case ESHL:
+ PickCommonsubAtRightRight(nd);
+ changed = 2;
+ break;
+ }
+ break;
+ case EXOR:
+ switch (left->nodetype) {
+ case ESHL:
+ case ESHR:
+ case EAND:
+ PickCommonsubAtRightRight(nd);
+ changed = 2;
+ break;
+ }
+ break;
+ case EAND:
+ case EOR:
+ if (left->nodetype == nd->nodetype) {
+ ReplaceExprWithLeftChild(right);
+ changed = 1;
+ } else if (
+ left->nodetype == ComplementaryOp[nd->nodetype] ||
+ left->nodetype == ESHR ||
+ left->nodetype == ESHL
+ )
+ {
+ PickCommonsubAtRightRight(nd);
+ changed = 2;
+ }
+ break;
+ }
+ } else if (left->nodetype == ComplementaryOp[right->nodetype]) {
+ switch (nd->nodetype) {
+ case EADD:
+ case EADDV:
+ switch (left->nodetype) {
+ case EADD:
+ case ESUB:
+ ReplaceExprWithLeftChild(left);
+ ReplaceExprWithLeftChild(right);
+ changed = 1;
+ break;
+ }
+ break;
+
+ case EAND:
+ case EOR:
+ if (left->nodetype == nd->nodetype)
+ ReplaceExprWithLeftChild(nd);
+ else if (right->nodetype == nd->nodetype)
+ ReplaceExprWithRightChild(nd);
+ break;
+ }
+ }
+ }
+
+ if (changed) {
+ DoDiadic(nd);
+ if (changed == 2)
+ DoDiadic(nd->u.diadic.left);
+ else if (changed == 3)
+ DoDiadic(nd->u.diadic.right);
+ IRO_Dump("remove common op at: %d\n", nd->index);
+ }
+ }
+ }
+}
+
+static void DoTransformations25(IROLinear *nd) {
+ int changed = 0;
+ IROLinear *left;
+ IROLinear *right;
+
+ if (nd->type == IROLinearOp2Arg) {
+ left = nd->u.diadic.left;
+ right = nd->u.diadic.right;
+
+ if (
+ (left->type == IROLinearOp2Arg && (IS_TYPE_FLOAT(left->u.diadic.left->rtype) || IS_TYPE_FLOAT(left->u.diadic.right->rtype))) ||
+ (right->type == IROLinearOp2Arg && (IS_TYPE_FLOAT(right->u.diadic.left->rtype) || IS_TYPE_FLOAT(right->u.diadic.right->rtype)))
+ )
+ return;
+
+ switch (left->nodetype) {
+ case ELESS:
+ case EGREATER:
+ case ELESSEQU:
+ case EGREATEREQU:
+ case EEQU:
+ case ENOTEQU:
+ switch (nd->nodetype) {
+ case EEQU:
+ if (IRO_IsConstantOne(right)) {
+ ReplaceExprWithLeftChild(nd);
+ changed = 1;
+ } else if (IRO_IsConstantZero(right)) {
+ left->nodetype = ComplementaryOpLogical[left->nodetype];
+ ReplaceExprWithLeftChild(nd);
+ changed = 1;
+ }
+ break;
+ case ENOTEQU:
+ if (IRO_IsConstantOne(right)) {
+ left->nodetype = ComplementaryOpLogical[left->nodetype];
+ ReplaceExprWithLeftChild(nd);
+ changed = 1;
+ } else if (IRO_IsConstantZero(right)) {
+ ReplaceExprWithLeftChild(nd);
+ changed = 1;
+ }
+ break;
+ }
+ break;
+ case ELAND:
+ case ELOR:
+ switch (nd->nodetype) {
+ case EEQU:
+ if (IRO_IsConstantOne(right)) {
+ ReplaceExprWithLeftChild(nd);
+ changed = 1;
+ }
+ break;
+ case ENOTEQU:
+ if (IRO_IsConstantZero(right)) {
+ ReplaceExprWithLeftChild(nd);
+ changed = 1;
+ }
+ break;
+ }
+ break;
+ }
+
+ if (!changed) {
+ switch (right->nodetype) {
+ case ELESS:
+ case EGREATER:
+ case ELESSEQU:
+ case EGREATEREQU:
+ case EEQU:
+ case ENOTEQU:
+ switch (nd->nodetype) {
+ case EEQU:
+ if (IRO_IsConstantOne(left)) {
+ ReplaceExprWithRightChild(nd);
+ } else if (IRO_IsConstantZero(left)) {
+ right->nodetype = ComplementaryOpLogical[right->nodetype];
+ ReplaceExprWithRightChild(nd);
+ }
+ break;
+ case ENOTEQU:
+ if (IRO_IsConstantOne(left)) {
+ right->nodetype = ComplementaryOpLogical[right->nodetype];
+ ReplaceExprWithRightChild(nd);
+ } else if (IRO_IsConstantZero(left)) {
+ ReplaceExprWithRightChild(nd);
+ }
+ break;
+ }
+ break;
+ case ELAND:
+ case ELOR:
+ switch (nd->nodetype) {
+ case EEQU:
+ if (IRO_IsConstantOne(left)) {
+ ReplaceExprWithRightChild(nd);
+ }
+ break;
+ case ENOTEQU:
+ if (IRO_IsConstantZero(left)) {
+ ReplaceExprWithRightChild(nd);
+ }
+ break;
+ }
+ break;
+ }
+ }
+ }
+}
+
+static Boolean isOrderingOperator(ENodeType op) {
+ switch (op) {
+ case ELAND:
+ case ELOR:
+ case ECOMMA:
+ case ECOND:
+ case ECONDASS:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+static void RemoveUnreffed(IROLinear *nd) {
+ if (!(nd->flags & IROLF_Reffed)) {
+ switch (nd->type) {
+ case IROLinearOperand:
+ IRO_NopNonSideEffects(nd, 0);
+ break;
+ case IROLinearOp1Arg:
+ case IROLinearOp2Arg:
+ case IROLinearOp3Arg:
+ case IROLinearFunccall:
+ if (!isOrderingOperator(nd->nodetype))
+ IRO_NopNonSideEffects(nd, 0);
+ break;
+ }
+ }
+}
+
+static void RemoveRedundantMonadicOp(IROLinear *nd) {
+ IROLinear *nd2;
+ IROLinear *nd3;
+
+ if (nd->type == IROLinearOp1Arg && (nd2 = IRO_LocateFather(nd)) && nd2->nodetype == nd->nodetype) {
+ switch (nd->nodetype) {
+ case ELOGNOT:
+ if ((nd3 = IRO_LocateFather(nd2))) {
+ if (
+ nd3->rtype &&
+ TYPE_INTEGRAL(nd3->rtype)->integral == IT_BOOL &&
+ nd->u.monadic->rtype &&
+ TYPE_INTEGRAL(nd->u.monadic->rtype)->integral == IT_BOOL
+ )
+ goto remove;
+
+ if (nd3->type == IROLinearIf)
+ goto remove;
+ if (nd3->type == IROLinearIfNot)
+ goto remove;
+ if (nd3->type == IROLinearOp3Arg && nd == nd3->u.args3.a)
+ goto remove;
+
+ switch (nd3->nodetype) {
+ case ELOGNOT:
+ case ELAND:
+ case ELOR:
+ goto remove;
+ }
+ }
+
+ if (nd->u.monadic->type == IROLinearOp1Arg || nd->u.monadic->type == IROLinearOp2Arg) {
+ switch (nd->u.monadic->nodetype) {
+ case ELOGNOT:
+ case ELESS:
+ case EGREATER:
+ case ELESSEQU:
+ case EGREATEREQU:
+ case EEQU:
+ case ENOTEQU:
+ case ELAND:
+ case ELOR:
+ goto remove;
+ }
+ }
+ break;
+
+ case EMONMIN:
+ case EBINNOT:
+ remove:
+ IRO_LocateFather_Cut_And_Paste_Without_Nopping(nd2, nd->u.monadic);
+ nd2->type = IROLinearNop;
+ nd->type = IROLinearNop;
+ break;
+
+ case ETYPCON:
+ if (TYPE_INTEGRAL(nd->rtype)->integral == IT_FLOAT) {
+ switch (TYPE_INTEGRAL(nd2->rtype)->integral) {
+ case IT_DOUBLE:
+ case IT_LONGDOUBLE:
+ switch (TYPE_INTEGRAL(nd->u.monadic->rtype)->integral) {
+ case IT_BOOL:
+ case IT_CHAR:
+ case IT_SCHAR:
+ case IT_UCHAR:
+ case IT_SHORT:
+ case IT_USHORT:
+ nd->type = IROLinearNop;
+ nd2->u.monadic = nd->u.monadic;
+ break;
+ }
+ break;
+ }
+ }
+ break;
+ }
+ }
+}
+
+static void ReverseOpForMonmin(IROLinear *nd) {
+ IROLinear *father;
+
+ if (
+ nd->type == IROLinearOp1Arg &&
+ nd->nodetype == EMONMIN &&
+ (father = IRO_LocateFather(nd)) &&
+ father->type == IROLinearOp2Arg &&
+ father->u.diadic.right == nd
+ )
+ {
+ switch (father->nodetype) {
+ case EADDV:
+ case ESUBV:
+ case EADD:
+ case ESUB:
+ case EADDASS:
+ case ESUBASS:
+ father->nodetype = ComplementaryOp[father->nodetype];
+ nd->type = IROLinearNop;
+ father->u.diadic.right = nd->u.monadic;
+ break;
+ }
+ }
+}
+
+static void DoDiadic(IROLinear *nd) {
+ RemoveUnreffed(nd);
+ DoTransformations(nd);
+ DoTransformations11(nd);
+ DoTransformations12(nd);
+ DoTransformations13(nd);
+ DoTransformations21(nd);
+ DoTransformations22(nd);
+ DoTransformations23(nd);
+ DoTransformations24(nd);
+ DoTransformations25(nd);
+}
+
+void IRO_DoTransformations(void) {
+ IROLinear *nd;
+
+ for (nd = IRO_FirstLinear; nd; nd = nd->next) {
+ switch (nd->type) {
+ case IROLinearOp2Arg:
+ DoDiadic(nd);
+ break;
+ case IROLinearOp1Arg:
+ RemoveUnreffed(nd);
+ RemoveRedundantMonadicOp(nd);
+ ReverseOpForMonmin(nd);
+ break;
+ case IROLinearOperand:
+ RemoveUnreffed(nd);
+ break;
+ }
+ }
+
+ IRO_CheckForUserBreak();
+}
+
+static Boolean ReconcileAssignments(IROLinear *nd1, IROLinear *nd2, IROList *list) {
+ IROLinear *copy;
+ Boolean result = 0;
+ int argCount;
+ int i;
+ IROLinear *tmp;
+
+ if (
+ (nd2->type == IROLinearOp1Arg && nd2->nodetype == ETYPCON) &&
+ !(nd1->type == IROLinearOp1Arg && nd1->nodetype == ETYPCON) &&
+ ReconcileAssignments(nd1, nd2->u.monadic, list)
+ )
+ {
+ result = 1;
+ }
+
+ if (
+ (nd1->type == IROLinearOp1Arg && nd1->nodetype == ETYPCON) &&
+ !(nd2->type == IROLinearOp1Arg && nd2->nodetype == ETYPCON) &&
+ ReconcileAssignments(nd1->u.monadic, nd2, list)
+ )
+ {
+ copy = IRO_NewLinear(IROLinearOp1Arg);
+ *copy = *nd2;
+ copy->index = IRO_NumLinear++;
+ copy->type = IROLinearOp1Arg;
+ copy->nodetype = ETYPCON;
+ copy->rtype = nd1->rtype;
+ copy->next = NULL;
+ copy->u.monadic = list->tail;
+ IRO_AddToList(copy, list);
+ result = 1;
+ }
+
+ if (nd1->type == nd2->type && nd1->nodetype == nd2->nodetype) {
+ copy = IRO_NewLinear(IROLinearNop);
+ *copy = *nd2;
+ copy->index = IRO_NumLinear++;
+ copy->rtype = nd1->rtype;
+ copy->next = NULL;
+ switch (nd1->type) {
+ case IROLinearOperand:
+ if (nd1->u.node->type == nd2->u.node->type) {
+ if (!(nd1->u.node->type == EOBJREF && nd1->u.node->data.objref != nd2->u.node->data.objref))
+ result = 1;
+ }
+ break;
+
+ case IROLinearOp1Arg:
+ if (ReconcileAssignments(nd1->u.monadic, nd2->u.monadic, list)) {
+ copy->u.monadic = list->tail;
+ result = 1;
+ }
+ break;
+
+ case IROLinearOp2Arg:
+ tmp = list->tail;
+ if (ReconcileAssignments(nd1->u.diadic.left, nd2->u.diadic.left, list)) {
+ copy->u.diadic.left = list->tail;
+ if (ReconcileAssignments(nd1->u.diadic.right, nd2->u.diadic.right, list)) {
+ copy->u.diadic.right = list->tail;
+ result = 1;
+ }
+ }
+
+ if (!result && !IRO_HasSideEffect(nd1) && !IRO_HasSideEffect(nd2)) {
+ if (nd1->nodetype == EMUL || nd1->nodetype == EADD || nd1->nodetype == EAND || nd1->nodetype == EXOR || nd1->nodetype == EOR) {
+ list->tail = tmp;
+ if (ReconcileAssignments(nd1->u.diadic.left, nd2->u.diadic.right, list)) {
+ copy->u.diadic.right = list->tail;
+ if (ReconcileAssignments(nd1->u.diadic.right, nd2->u.diadic.left, list)) {
+ copy->u.diadic.left = list->tail;
+ result = 1;
+ }
+ }
+ }
+ }
+ break;
+
+ case IROLinearOp3Arg:
+ if (ReconcileAssignments(nd1->u.args3.c, nd2->u.args3.c, list)) {
+ copy->u.args3.c = list->tail;
+ if (ReconcileAssignments(nd1->u.args3.b, nd2->u.args3.b, list)) {
+ copy->u.args3.b = list->tail;
+ if (ReconcileAssignments(nd1->u.args3.a, nd2->u.args3.a, list)) {
+ copy->u.args3.a = list->tail;
+ result = 1;
+ }
+ }
+ }
+ break;
+
+ case IROLinearFunccall:
+ argCount = nd1->u.funccall.argCount;
+ if (argCount == nd2->u.funccall.argCount) {
+ result = 1;
+ copy->u.funccall.args = oalloc(sizeof(IROLinear *) * argCount);
+ for (i = argCount - 1; i >= 0; i--) {
+ if (!ReconcileAssignments(nd1->u.funccall.args[i], nd2->u.funccall.args[i], list)) {
+ result = 0;
+ break;
+ }
+ copy->u.funccall.args[i] = list->tail;
+ }
+
+ if (result) {
+ if (!ReconcileAssignments(nd1->u.funccall.linear8, nd2->u.funccall.linear8, list)) {
+ result = 0;
+ break;
+ }
+ copy->u.funccall.linear8 = list->tail;
+ }
+ }
+ break;
+ }
+
+ if (result)
+ IRO_AddToList(copy, list);
+ }
+
+ return result;
+}
+
+static IROLinear *FrontendTransformSelfAssignmentToAssignment(IROLinear *nd) {
+ Statement *stmt;
+ IROList list;
+ IROLinearIRSave save;
+
+ IRO_SaveLinearIR(&save);
+
+ IRO_InitList(&list);
+ IRO_DuplicateExpr(nd, &list);
+
+ stmt = IRO_Delinearize(NULL, list.head);
+ CError_ASSERT(3550, stmt);
+ CError_ASSERT(3552, stmt->expr);
+ stmt->expr = CIRTrans_TransformOpAss(stmt->expr);
+ CError_ASSERT(3557, stmt->expr);
+
+ if (DoLinearize)
+ IRO_PreLinearize(stmt);
+ IRO_Linearize(stmt);
+
+ IRO_InitList(&list);
+ list.head = IRO_FirstLinear;
+ list.tail = IRO_LastLinear;
+
+ IRO_RestoreLinearIR(&save);
+
+ for (nd = list.head; nd; nd = nd->next) {
+ if (!(nd->flags & IROLF_Reffed) && IRO_IsAssignment(nd))
+ break;
+ }
+
+ return nd;
+}
+
+static Type *PromotedIntegralType(Type *type) {
+ CError_ASSERT(3586, IS_TYPE_ENUM(type) || IS_TYPE_INT(type));
+
+ if (IS_TYPE_ENUM(type))
+ type = TYPE_ENUM(type)->enumtype;
+
+ if (TYPE_INTEGRAL(type)->integral < IT_INT) {
+ if (IRO_IsUnsignedType(type))
+ return TYPE(&stunsignedint);
+ else
+ return TYPE(&stsignedint);
+ } else {
+ return type;
+ }
+}
+
+static Boolean TransformMonadicSelfAssignmentToDiadicSelfAssignment(IROLinear *nd) {
+ ENodeType t;
+ ENodeType newtype;
+ IROLinear *incExpr;
+ IROLinear *varExpr;
+
+ t = nd->nodetype;
+
+ if (IRO_IsAssignment(nd) && IRO_IsModifyOp[t]) {
+ incExpr = NULL;
+ varExpr = NULL;
+ newtype = MAXEXPR;
+
+ if (
+ nd->type == IROLinearOp1Arg &&
+ (t == EPOSTINC || t == EPOSTDEC || t == EPREINC || t == EPREDEC) &&
+ (!(nd->flags & IROLF_Reffed) || t == EPREINC || t == EPREDEC)
+ )
+ {
+ Type *type = nd->rtype;
+ TypeType typetype = type->type;
+ varExpr = nd->u.monadic;
+ if (typetype == TYPEINT || typetype == TYPEENUM) {
+ incExpr = IRO_NewIntConst(cint64_one, PromotedIntegralType(type));
+ } else if (typetype == TYPEPOINTER || typetype == TYPEARRAY || typetype == TYPEMEMBERPOINTER) {
+ Type *inner = NULL;
+ CInt64 val = cint64_zero;
+
+ if (typetype == TYPEPOINTER || typetype == TYPEARRAY)
+ inner = TPTR_TARGET(type);
+ else if (typetype == TYPEMEMBERPOINTER)
+ inner = TYPE_MEMBER_POINTER(type)->ty1;
+
+ if (inner)
+ CInt64_SetLong(&val, inner->size);
+
+ if (!CInt64_IsZero(&val)) {
+ incExpr = IRO_NewIntConst(val, TYPE(&stsignedlong));
+ } else {
+ return 0;
+ }
+ } else if (typetype == TYPEFLOAT) {
+ Float fval;
+ fval = CMach_CalcFloatConvertFromInt(type, cint64_one);
+ incExpr = IRO_NewFloatConst(fval, nd->rtype);
+ } else {
+ return 0;
+ }
+
+ if (t == EPOSTINC || t == EPREINC)
+ newtype = EADDASS;
+ else
+ newtype = ESUBASS;
+ }
+
+ if (
+ varExpr &&
+ incExpr &&
+ newtype != MAXEXPR &&
+ varExpr->u.diadic.left &&
+ varExpr->u.diadic.left->type == IROLinearOperand &&
+ varExpr->u.diadic.left->u.node &&
+ varExpr->u.diadic.left->u.node->type == EOBJREF &&
+ !IRO_HasSideEffect(varExpr)
+ )
+ {
+ incExpr->flags |= IROLF_Reffed;
+ nd->nodetype = newtype;
+ nd->u.diadic.right = incExpr;
+ nd->type = IROLinearOp2Arg;
+ IRO_Paste(incExpr, incExpr, nd);
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+Boolean IRO_TransformSelfAssignmentToAssignment(IROLinear *nd) {
+ ENodeType nonAssOp;
+ IROLinear *left;
+ IROLinear *right;
+ ENodeType nodetype;
+ IROLinear *nonAss;
+ IROLinear *dupLeft;
+ IROLinear *last;
+ IROList list1;
+ IROList list2;
+
+ nodetype = nd->nodetype;
+ if (
+ IRO_IsAssignment(nd) &&
+ IRO_IsModifyOp[nodetype] &&
+ nd->type == IROLinearOp1Arg &&
+ TransformMonadicSelfAssignmentToDiadicSelfAssignment(nd)
+ )
+ nodetype = nd->nodetype;
+
+ if (
+ IRO_IsAssignment(nd) &&
+ IRO_IsModifyOp[nodetype] &&
+ nd->type == IROLinearOp2Arg &&
+ IRO_NonAssignmentOp[nodetype] != MAXEXPR
+ )
+ {
+ left = nd->u.diadic.left;
+ right = nd->u.diadic.right;
+ nonAssOp = IRO_NonAssignmentOp[nodetype];
+ if (
+ left &&
+ right &&
+ nonAssOp != MAXEXPR &&
+ left->u.monadic &&
+ left->u.monadic->type == IROLinearOperand &&
+ left->u.monadic->u.node &&
+ left->u.monadic->u.node->type == EOBJREF &&
+ !IRO_HasSideEffect(left)
+ )
+ {
+ IRO_InitList(&list1);
+ dupLeft = IRO_DuplicateExpr(left, &list1);
+
+ if (left->rtype != right->rtype) {
+ IROLinear *tmp = IRO_NewLinear(IROLinearOp1Arg);
+ tmp->nodetype = ETYPCON;
+ tmp->flags |= IROLF_Reffed;
+ tmp->rtype = right->rtype;
+ tmp->index = ++IRO_NumLinear;
+ tmp->u.monadic = dupLeft;
+ IRO_AddToList(tmp, &list1);
+ dupLeft = tmp;
+ }
+
+ nonAss = IRO_NewLinear(IROLinearOp2Arg);
+ nonAss->nodetype = nonAssOp;
+ nonAss->flags |= IROLF_Reffed;
+ nonAss->rtype = dupLeft->rtype;
+ nonAss->index = ++IRO_NumLinear;
+ nonAss->u.diadic.left = dupLeft;
+ nonAss->u.diadic.right = right;
+ IRO_AddToList(nonAss, &list1);
+
+ if (left->rtype != right->rtype) {
+ IROLinear *tmp = IRO_NewLinear(IROLinearOp1Arg);
+ tmp->nodetype = ETYPCON;
+ tmp->flags |= IROLF_Reffed;
+ tmp->rtype = left->rtype;
+ tmp->index = ++IRO_NumLinear;
+ tmp->u.monadic = nonAss;
+ IRO_AddToList(tmp, &list1);
+ nonAss = tmp;
+ }
+
+ IRO_InitList(&list2);
+ last = FrontendTransformSelfAssignmentToAssignment(nd);
+ if (
+ last &&
+ last->type == IROLinearOp2Arg &&
+ ReconcileAssignments(last->u.diadic.right, nonAss, &list2)
+ )
+ {
+ IRO_NopOut(nd->u.diadic.right);
+ nd->nodetype = EASS;
+ nd->u.diadic.right = list2.tail;
+ nd->type = IROLinearOp2Arg;
+ IRO_Paste(list2.head, list2.tail, nd);
+ return 1;
+ }
+ }
+ }
+
+ return 0;
+}
+
+static void AddAddend(ENode *expr) {
+ if (expr->type == EADD) {
+ AddAddend(expr->data.diadic.left);
+ AddAddend(expr->data.diadic.right);
+ } else {
+ ENodeList *list = oalloc(sizeof(ENodeList));
+ list->node = expr;
+ list->next = NULL;
+
+ if (FirstAddend)
+ LastAddend->next = list;
+ else
+ FirstAddend = list;
+ LastAddend = list;
+ }
+}
+
+static ENode *CombineConstants(ENode *expr) {
+ ENode *addend;
+ ENodeList *el;
+ ENode *result;
+ ENode *var;
+ Type *type;
+ ENode *tmp;
+ ENodeList *prev;
+ CInt64 val;
+
+ FirstAddend = LastAddend = NULL;
+ AddAddend(expr->data.diadic.left);
+ AddAddend(expr->data.diadic.right);
+
+ // these variable names are courtesy of the resource fork in abort_exit.c
+ el = FirstAddend;
+ prev = NULL;
+ var = NULL;
+ while (el) {
+ addend = el->node;
+ if (addend->type == EOBJREF) {
+ var = addend;
+ if (prev)
+ prev->next = el->next;
+ else
+ FirstAddend = el->next;
+ break;
+ }
+ prev = el;
+ el = el->next;
+ }
+
+ if (!var) {
+ el = FirstAddend;
+ prev = NULL;
+ while (el) {
+ addend = el->node;
+ if (addend->type == EINDIRECT) {
+ var = addend;
+ if (prev)
+ prev->next = el->next;
+ else
+ FirstAddend = el->next;
+ break;
+ }
+ prev = el;
+ el = el->next;
+ }
+ }
+
+ prev = NULL;
+ CInt64_SetLong(&val, 0);
+ type = NULL;
+
+ for (el = FirstAddend; el; el = el->next) {
+ addend = el->node;
+ if (addend->type == EINTCONST && addend->rtype) {
+ if (!type || type->size < addend->rtype->size)
+ type = addend->rtype;
+ val = CInt64_Add(val, addend->data.intval);
+ if (prev)
+ prev->next = el->next;
+ else
+ FirstAddend = el->next;
+ } else if (addend->type == EMUL && addend->data.diadic.right->type == EINTCONST && addend->rtype) {
+ if (!type || type->size < addend->rtype->size)
+ type = addend->rtype;
+
+ tmp = addend->data.diadic.left;
+ if (tmp->type == EADD && tmp->data.diadic.right->type == EINTCONST) {
+ val = CInt64_Add(val, CInt64_MulU(tmp->data.diadic.right->data.intval, addend->data.diadic.right->data.intval));
+ addend->data.diadic.left = tmp->data.diadic.left;
+ }
+ prev = el;
+ } else {
+ prev = el;
+ }
+ }
+
+ result = NULL;
+ if (var) {
+ result = var;
+ if (!CInt64_IsZero(&val)) {
+ result = IRO_NewENode(EADD);
+ result->data.diadic.left = var;
+ result->data.diadic.right = IRO_NewENode(EINTCONST);
+ result->data.diadic.right->data.intval = val;
+ result->data.diadic.right->rtype = type;
+ result->rtype = var->rtype;
+ result->cost = 1;
+ CInt64_SetLong(&val, 0);
+ }
+ }
+
+ for (el = FirstAddend; el; el = el->next) {
+ addend = el->node;
+ if (result) {
+ tmp = IRO_NewENode(EADD);
+ tmp->data.diadic.left = result;
+ tmp->data.diadic.right = addend;
+ tmp->cost = result->cost + 1;
+ tmp->rtype = result->rtype;
+ result = tmp;
+ } else {
+ result = addend;
+ }
+ }
+
+ if (!CInt64_IsZero(&val)) {
+ tmp = IRO_NewENode(EADD);
+ tmp->data.diadic.left = result;
+ tmp->data.diadic.right = IRO_NewENode(EINTCONST);
+ tmp->data.diadic.right->data.intval = val;
+ tmp->data.diadic.right->rtype = type;
+ tmp->cost = result->cost + 1;
+ tmp->rtype = result->rtype;
+ result = tmp;
+ }
+
+ return result;
+}
+
+static ENode *TransformExprNode(ENode *expr) {
+ ENode *left;
+ ENode *right;
+
+ switch (expr->type) {
+ case EINDIRECT:
+ if (ENODE_IS(expr->data.monadic, EADD))
+ expr->data.monadic = CombineConstants(expr->data.monadic);
+ break;
+
+ case EMUL:
+ case EADD:
+ case EAND:
+ case EXOR:
+ case EOR:
+ if (
+ IS_TYPE_INT(expr->rtype) &&
+ !ENODE_IS(right = expr->data.diadic.right, EINTCONST) &&
+ ENODE_IS(left = expr->data.diadic.left, EINTCONST)
+ )
+ {
+ expr->data.diadic.left = right;
+ expr->data.diadic.right = left;
+ }
+ break;
+
+ case EEQU:
+ case ENOTEQU:
+ if (
+ IS_TYPE_INT(expr->rtype) &&
+ !ENODE_IS(left = expr->data.diadic.right, EINTCONST) &&
+ ENODE_IS(right = expr->data.diadic.left, EINTCONST)
+ )
+ {
+ expr->data.diadic.left = left;
+ expr->data.diadic.right = right;
+ }
+
+ if (
+ ENODE_IS(expr->data.diadic.right, EINTCONST) &&
+ ENODE_IS(left = expr->data.diadic.left, EBINNOT)
+ )
+ {
+ expr->data.diadic.left = left->data.monadic;
+ left->data.monadic = expr->data.diadic.right;
+ expr->data.diadic.right = left;
+ }
+
+ break;
+ }
+
+ return expr;
+}
+
+static ENode *TransformExprTree(ENode *expr) {
+ ENodeList *list;
+
+ switch (expr->type) {
+ ENODE_CASE_MONADIC:
+ expr->data.monadic = TransformExprTree(expr->data.monadic);
+ break;
+
+ ENODE_CASE_DIADIC_ALL:
+ expr->data.diadic.left = TransformExprTree(expr->data.diadic.left);
+ expr->data.diadic.right = TransformExprTree(expr->data.diadic.right);
+ break;
+
+ case EFUNCCALL:
+ case EFUNCCALLP:
+ TransformExprTree(expr->data.funccall.funcref);
+ for (list = expr->data.funccall.args; list; list = list->next)
+ TransformExprTree(list->node);
+ break;
+
+ case ECOND:
+ TransformExprTree(expr->data.cond.cond);
+ TransformExprTree(expr->data.cond.expr1);
+ TransformExprTree(expr->data.cond.expr2);
+ break;
+
+ case ENULLCHECK:
+ TransformExprTree(expr->data.nullcheck.nullcheckexpr);
+ TransformExprTree(expr->data.nullcheck.condexpr);
+ break;
+ }
+
+ return TransformExprNode(expr);
+}
+
+static void FoldConstantsinAssociativeExprs(ENode *expr) {
+ short nodetype1;
+ short nodetype2;
+ short nodetype3;
+ Boolean changed;
+ short op;
+ CInt64 val1;
+ CInt64 val2;
+ CInt64 tmpval;
+
+ if (
+ (
+ expr->type == EADD ||
+ expr->type == EMUL ||
+ expr->type == EAND ||
+ expr->type == EXOR ||
+ expr->type == EOR ||
+ expr->type == ESHL ||
+ expr->type == ESHR
+ ) &&
+ IS_TYPE_INT(expr->rtype) &&
+ expr->data.diadic.right->type == EINTCONST
+ )
+ {
+ do {
+ changed = 0;
+
+ if (
+ expr->data.diadic.left->type == expr->type &&
+ expr->data.diadic.left->data.diadic.right->type == EINTCONST
+ )
+ {
+ val1 = expr->data.diadic.right->data.intval;
+ val2 = expr->data.diadic.left->data.diadic.right->data.intval;
+ switch (expr->type) {
+ case EADD:
+ case ESHL:
+ op = '+';
+ break;
+ case ESHR:
+ op = '+';
+ if (!IRO_IsUnsignedType(expr->rtype)) {
+ CInt64_SetLong(&tmpval, expr->rtype->size * 8);
+ if (CInt64_GreaterEqualU(val1, tmpval) || CInt64_GreaterEqualU(val2, tmpval))
+ return;
+
+ if (CInt64_GreaterEqualU(CMach_CalcIntDiadic(expr->rtype, val1, '+', val2), tmpval)) {
+ val1 = CInt64_Sub(tmpval, cint64_one);
+ val2 = cint64_zero;
+ }
+ }
+ break;
+ case EMUL:
+ op = '*';
+ break;
+ case EAND:
+ op = '&';
+ break;
+ case EOR:
+ op = '|';
+ break;
+ case EXOR:
+ op = '^';
+ break;
+ default:
+ return;
+ }
+
+ expr->data.diadic.right->data.intval = CMach_CalcIntDiadic(expr->rtype, val1, op, val2);
+ expr->data.diadic.left = expr->data.diadic.left->data.diadic.left;
+ changed = 1;
+ } else if (
+ ((nodetype1 = expr->type) == EAND || nodetype1 == EOR) &&
+ ((nodetype2 = expr->data.diadic.left->type) == EAND || nodetype2 == EOR) &&
+ ((nodetype3 = expr->data.diadic.left->data.diadic.left->type) == EAND || nodetype3 == EOR) &&
+ expr->data.diadic.left->data.diadic.left->data.diadic.right->type == EINTCONST
+ )
+ {
+ val1 = expr->data.diadic.right->data.intval;
+ if (CInt64_Equal(val1, expr->data.diadic.left->data.diadic.left->data.diadic.right->data.intval)) {
+ if (nodetype1 == nodetype3) {
+ expr->data.diadic.left->data.diadic.left = expr->data.diadic.left->data.diadic.left->data.diadic.left;
+ changed = 1;
+ } else if (nodetype2 == nodetype3) {
+ *expr = *expr->data.diadic.right;
+ changed = 1;
+ } else {
+ expr->data.diadic.left = expr->data.diadic.left->data.diadic.right;
+ changed = 1;
+ }
+ }
+ }
+ } while (changed);
+ }
+}
+
+static void TransformExprTree1(ENode *expr) {
+ ENodeList *list;
+
+ switch (expr->type) {
+ ENODE_CASE_MONADIC:
+ TransformExprTree1(expr->data.monadic);
+ break;
+
+ ENODE_CASE_DIADIC_ALL:
+ TransformExprTree1(expr->data.diadic.left);
+ TransformExprTree1(expr->data.diadic.right);
+ break;
+
+ case EFUNCCALL:
+ case EFUNCCALLP:
+ TransformExprTree1(expr->data.funccall.funcref);
+ for (list = expr->data.funccall.args; list; list = list->next)
+ TransformExprTree1(list->node);
+ break;
+
+ case ECOND:
+ TransformExprTree1(expr->data.cond.cond);
+ TransformExprTree1(expr->data.cond.expr1);
+ TransformExprTree1(expr->data.cond.expr2);
+ break;
+
+ case ENULLCHECK:
+ TransformExprTree1(expr->data.nullcheck.nullcheckexpr);
+ TransformExprTree1(expr->data.nullcheck.condexpr);
+ break;
+ }
+
+ FoldConstantsinAssociativeExprs(expr);
+}
+
+static int RemoveRedundantBitOperations(ENode *expr) {
+ Boolean a;
+ Boolean b;
+
+ if (expr->type == ExprType) {
+ a = RemoveRedundantBitOperations(expr->data.diadic.left);
+ b = RemoveRedundantBitOperations(expr->data.diadic.right);
+ return a & b;
+ }
+
+ if (expr->type == EINDIRECT) {
+ if (expr->data.monadic->type == EOBJREF) {
+ if (!OperandObject) {
+ OperandObject = expr->data.monadic->data.objref;
+ IndirectRef = expr;
+ return 1;
+ } else {
+ return expr->data.monadic->data.objref == OperandObject;
+ }
+ } else {
+ return 0;
+ }
+ }
+
+ if (expr->type == EINTCONST) {
+ if (FirstTime) {
+ OperandConst = expr->data.intval;
+ FirstTime = 0;
+ } else if (ExprType == EAND) {
+ OperandConst = CInt64_And(expr->data.intval, OperandConst);
+ } else if (ExprType == EOR) {
+ OperandConst = CInt64_Or(expr->data.intval, OperandConst);
+ } else if (ExprType == EXOR) {
+ OperandConst = CInt64_Xor(expr->data.intval, OperandConst);
+ }
+ return 1;
+ }
+
+ return 0;
+}
+
+static void TransformExprTree2(ENode *expr) {
+ ENodeList *list;
+
+ switch (expr->type) {
+ ENODE_CASE_MONADIC:
+ TransformExprTree2(expr->data.monadic);
+ break;
+
+ ENODE_CASE_DIADIC_ALL:
+ TransformExprTree2(expr->data.diadic.left);
+ TransformExprTree2(expr->data.diadic.right);
+ break;
+
+ case EFUNCCALL:
+ case EFUNCCALLP:
+ TransformExprTree2(expr->data.funccall.funcref);
+ for (list = expr->data.funccall.args; list; list = list->next)
+ TransformExprTree2(list->node);
+ break;
+
+ case ECOND:
+ TransformExprTree2(expr->data.cond.cond);
+ TransformExprTree2(expr->data.cond.expr1);
+ TransformExprTree2(expr->data.cond.expr2);
+ break;
+
+ case ENULLCHECK:
+ TransformExprTree2(expr->data.nullcheck.nullcheckexpr);
+ TransformExprTree2(expr->data.nullcheck.condexpr);
+ break;
+ }
+
+ if (
+ ENODE_IS3(expr, EAND, EOR, EXOR) &&
+ (expr->type == expr->data.diadic.left->type || expr->type == expr->data.diadic.right->type)
+ )
+ {
+ OperandObject = NULL;
+ ExprType = expr->type;
+ FirstTime = 1;
+ IndirectRef = NULL;
+
+ if (RemoveRedundantBitOperations(expr)) {
+ expr->data.diadic.left = IndirectRef;
+ expr->data.diadic.right->type = EINTCONST;
+ expr->data.diadic.right->data.intval = OperandConst;
+ }
+ }
+}
+
+static void PullOutPostOps(Statement *stmt, ENode **pExpr) {
+ ENode *ind;
+ ENode *inner;
+ Statement *newStmt;
+
+ switch ((*pExpr)->type) {
+ ENODE_CASE_MONADIC:
+ if ((*pExpr)->type != EFORCELOAD)
+ PullOutPostOps(stmt, &(*pExpr)->data.monadic);
+
+ if (ENODE_IS2(*pExpr, EPOSTINC, EPOSTDEC)) {
+ inner = (*pExpr)->data.monadic;
+ if (
+ ENODE_IS(inner, EINDIRECT) &&
+ inner->rtype &&
+ !CParser_IsVolatile(inner->rtype, ENODE_QUALS(inner)) &&
+ ENODE_IS(inner->data.monadic, EOBJREF) &&
+ !is_volatile_object(inner->data.monadic->data.objref)
+ )
+ {
+ newStmt = lalloc(sizeof(Statement));
+ memset(newStmt, 0, sizeof(Statement));
+ newStmt->type = ST_EXPRESSION;
+ newStmt->expr = *pExpr;
+ newStmt->dobjstack = stmt->dobjstack;
+ newStmt->sourceoffset = stmt->sourceoffset;
+ newStmt->sourcefilepath = stmt->sourcefilepath;
+ newStmt->value = stmt->value;
+ newStmt->flags = stmt->flags;
+ newStmt->next = stmt->next;
+ stmt->next = newStmt;
+
+ ind = IRO_NewENode(EINDIRECT);
+ *ind = *inner;
+ ind->data.monadic = IRO_NewENode(EOBJREF);
+ *ind->data.monadic = *inner->data.monadic;
+ *pExpr = ind;
+ }
+ }
+ break;
+
+ ENODE_CASE_DIADIC_ALL:
+ if (ENODE_IS(*pExpr, ECOND))
+ break;
+ if (ENODE_IS(*pExpr, ECOMMA))
+ break;
+ if (ENODE_IS(*pExpr, ELOR))
+ break;
+ if (ENODE_IS(*pExpr, ELAND))
+ break;
+ if (ENODE_IS(*pExpr, ENULLCHECK))
+ break;
+ PullOutPostOps(stmt, &(*pExpr)->data.diadic.left);
+ PullOutPostOps(stmt, &(*pExpr)->data.diadic.right);
+ break;
+ }
+}
+
+void IRO_TransformTree(Statement *statements) {
+ Statement *stmt;
+ Statement *next;
+
+ for (stmt = statements; stmt; stmt = next) {
+ next = stmt->next;
+ switch (stmt->type) {
+ case ST_EXPRESSION:
+ case ST_SWITCH:
+ case ST_IFGOTO:
+ case ST_IFNGOTO:
+ case ST_RETURN:
+ if (stmt->expr) {
+ stmt->expr = TransformExprTree(stmt->expr);
+ TransformExprTree2(stmt->expr);
+ TransformExprTree1(stmt->expr);
+ }
+ break;
+ }
+ }
+
+ IRO_CheckForUserBreak();
+}
diff --git a/compiler_and_linker/unsorted/IroUnrollLoop.c b/compiler_and_linker/unsorted/IroUnrollLoop.c
index f5c4fb0..5bbe490 100644
--- a/compiler_and_linker/unsorted/IroUnrollLoop.c
+++ b/compiler_and_linker/unsorted/IroUnrollLoop.c
@@ -1,8 +1,38 @@
#include "compiler/IroUnrollLoop.h"
+#include "compiler/CError.h"
+#include "compiler/IroFlowgraph.h"
+#include "compiler/IroLinearForm.h"
#include "compiler/IroUtil.h"
+#include "compiler/LoopDetection.h"
+#include "compiler/IroLoop.h"
+#include "compiler/IroDump.h"
+#include "compiler/IroVars.h"
+#include "compiler/CFunc.h"
+#include "compiler/CMachine.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+typedef struct LoopList {
+ UInt8 flags;
+ BitVector *bv;
+ struct LoopList *next;
+ IRONode *fnode;
+ int xE;
+} LoopList;
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
// forward decls
static void IRO_FindLoops_Unroll(void);
+static void LoopUnroll(int count, IRONode *fnode);
+static int IsLoopUnrollable(IROLoop *loop);
+static int IsDifferenceOfTermsConstant(IROAddrRecord *lowerRec, IROAddrRecord *upperRec, int isUnsigned, CInt64 *pval);
+static IROLinear *BuildOrigIterationCount_DoWhile(IROList *list, IROLoop *loop);
+static IROLinear *BuildPreAlignTemp(IROLoopInd *ind, UInt32 unrollFactor, IROList *list);
+static IROLinear *BuildNewFinalvalue_DoWhile(IROLinear *iterCount, UInt32 unrollFactor, IROList *list, IROLoop *loop);
+static IROLinear *BuildUnrolledFinalvalue_DoWhile(IROLinear *iterCount, UInt32 unrollFactor, IROList *list, IROLoop *loop);
void IRO_LoopUnroller(void) {
VectorPhaseCalledFromUnroll = 1;
@@ -11,85 +41,2265 @@ void IRO_LoopUnroller(void) {
}
static void IRO_FindLoops_Unroll(void) {
+ IRONode *fnode;
+ IRONode *pred;
+ UInt16 i;
+ UInt16 flag;
+ LoopList *list;
+ LoopList *list2;
+
+ fnode = IRO_FirstNode;
+ LoopList_First = NULL;
+
+ while (fnode) {
+ flag = 0;
+ for (i = 0; i < fnode->numpred; i++) {
+ pred = IRO_NodeTable[fnode->pred[i]];
+ if (Bv_IsBitSet(fnode->index, pred->dom)) {
+ if (!flag) {
+ Bv_AllocVector(&InLoop, IRO_NumNodes + 1);
+ Bv_Clear(InLoop);
+ Bv_SetBit(fnode->index, InLoop);
+ }
+ flag = 1;
+ Bv_SetBit(pred->index, InLoop);
+ if (pred != fnode)
+ AddPreds(pred);
+ }
+ }
+
+ if (flag) {
+ if (!LoopList_First) {
+ list = oalloc(sizeof(LoopList));
+ list->next = NULL;
+ } else {
+ list = oalloc(sizeof(LoopList));
+ list->next = LoopList_First;
+ }
+ LoopList_First = list;
+
+ Bv_AllocVector(&list->bv, IRO_NumNodes + 1);
+ list->flags |= 1;
+ Bv_Copy(InLoop, list->bv);
+ list->fnode = fnode;
+ list->xE = 0;
+ }
+
+ fnode = fnode->nextnode;
+ }
+
+ list = LoopList_First;
+ Bv_AllocVector(&LoopTemp, IRO_NumNodes + 1);
+ while (list) {
+ for (list2 = LoopList_First; list2; list2 = list2->next) {
+ if (list2 != list) {
+ IRO_Dump(" header = %d \n", list2->fnode->index);
+ IRO_Dump(" l1 bit vector=\n");
+ IRO_DumpBits("", list2->bv);
+ IRO_Dump(" l bit vector=\n");
+ IRO_DumpBits("", list->bv);
+ if (Bv_IsSubset(list->bv, list2->bv))
+ list2->flags &= ~1;
+ }
+ }
+ list = list->next;
+ }
+
+ for (list = LoopList_First; list; list = list->next) {
+ if (list->flags & 1) {
+ IRONode *listfnode;
+ Bv_Copy(list->bv, InLoop);
+ listfnode = list->fnode;
+ IRO_Dump("IRO_FindLoops_Unroll:Found loop with header %d\n", listfnode->index);
+ IRO_DumpBits("Loop includes: ", InLoop);
+ LoopUnroll(copts.loop_unroll_count, listfnode);
+ IRO_UpdateFlagsOnInts();
+ }
+ }
}
-static void CheckConstant() {
+static int CheckConstant(CInt64 a, CInt64 b, CInt64 *result) {
+ CInt64 shl = cint64_zero;
+ CInt64 work = cint64_zero;
+ CInt64 and = cint64_zero;
+ CInt64 i;
+
+ for (i = cint64_zero; CInt64_Less(i, a); i = CInt64_Add(i, cint64_one)) {
+ shl = CInt64_Shl(b, i);
+ and = CInt64_And(shl, work);
+ if (CInt64_NotEqual(and, cint64_zero))
+ return 0;
+ work = CInt64_Or(shl, work);
+ }
+
+ *result = work;
+ return 1;
}
-static void UnrollWhileLoopBody() {
+typedef struct LoopPattern {
+ IROLinear *nd0;
+ IROLinear *nd4;
+ Type *type;
+ IROLinear *ndC;
+ IROLinear *nd10;
+ CInt64 val14;
+ CInt64 val1C;
+} LoopPattern;
+
+static void UnrollWhileLoopBody(IRONode *header, IRONode *fnode2, IRONode *fnode3, IROLoop *loop, LoopPattern *pattern, UInt32 unrollFactor) {
+ IRONode *scan;
+ int pass;
+ IROLinear *firstnode;
+ IROLinear *lastnd;
+ IROLinear *nd;
+ IROLinear *nd1;
+ IROLinear *nd2;
+ IROLinear *nd3;
+ IROLinear *nd4;
+ IROLinear *nd5;
+ IROLinear *nd6;
+ IROLinear *nd8;
+ IROLinear *nd7;
+ ENode *expr;
+ IROList list;
+ CInt64 zero;
+ CInt64 shiftval;
+
+ CInt64_SetLong(&zero, 0);
+
+ pass = 0;
+
+ do {
+ firstnode = NULL;
+ for (scan = fnode3; scan && scan != header; scan = scan->nextnode) {
+ IRO_InitList(&list);
+ lastnd = scan->last;
+ nd = scan->first;
+ while (1) {
+ if (nd->stmt)
+ nd->stmt->flags |= StmtFlag_10;
+
+ if (
+ (nd->index < loop->index20 || nd->index > loop->index24) &&
+ nd->type != IROLinearLabel &&
+ nd->type != IROLinearNop &&
+ !(nd->flags & IROLF_Reffed)
+ )
+ {
+ CError_ASSERT(345, nd->nodetype == EORASS || nd->nodetype == EANDASS || nd->nodetype == EXORASS);
+
+ IRO_DuplicateExpr(pattern->nd0, &list);
+ nd1 = list.tail;
+
+ shiftval = cint64_one;
+ shiftval = CInt64_Shl(shiftval, pattern->val1C);
+
+ nd2 = IRO_NewLinear(IROLinearOperand);
+ nd2->index = ++IRO_NumLinear;
+ nd2->rtype = pattern->nd0->rtype;
+ expr = IRO_NewENode(EINTCONST);
+ expr->rtype = pattern->nd0->rtype;
+ CInt64_SetLong(&expr->data.intval, pass * CInt64_GetULong(&shiftval));
+ nd2->u.node = expr;
+ IRO_AddToList(nd2, &list);
+
+ IRO_DuplicateExpr(pattern->nd4, &list);
+
+ nd3 = IRO_NewLinear(IROLinearOp2Arg);
+ nd3->index = ++IRO_NumLinear;
+ nd3->nodetype = EADD;
+ nd3->rtype = pattern->type;
+ nd3->u.diadic.left = list.tail;
+ nd3->u.diadic.right = nd2;
+ IRO_AddToList(nd3, &list);
+
+ nd4 = IRO_NewLinear(IROLinearOp2Arg);
+ nd4->index = ++IRO_NumLinear;
+ nd4->nodetype = EADD;
+ nd4->rtype = pattern->type;
+ nd4->u.diadic.left = nd3;
+ nd4->u.diadic.right = nd1;
+ IRO_AddToList(nd4, &list);
+
+ nd5 = IRO_NewLinear(IROLinearOp1Arg);
+ nd5->index = ++IRO_NumLinear;
+ nd5->nodetype = EINDIRECT;
+ nd5->rtype = nd->rtype;
+ nd5->u.monadic = nd4;
+ IRO_AddToList(nd5, &list);
+
+ nd6 = IRO_NewLinear(IROLinearOp2Arg);
+ *nd6 = *nd;
+ nd6->index = ++IRO_NumLinear;
+ nd6->u.diadic.left = list.tail;
+ nd6->next = NULL;
+
+ nd7 = IRO_NewLinear(IROLinearOperand);
+ nd7->index = ++IRO_NumLinear;
+ nd7->rtype = pattern->ndC->rtype;
+ expr = IRO_NewENode(EINTCONST);
+ expr->rtype = pattern->ndC->rtype;
+ nd7->u.node = expr;
+ nd7->next = NULL;
+ expr->data.intval = pattern->val14;
+
+ if (
+ IS_LINEAR_DIADIC(nd, EANDASS) &&
+ CInt64_Equal(pattern->val14, cint64_zero)
+ )
+ {
+ nd6->nodetype = EASS;
+ } else if (
+ IS_LINEAR_DIADIC(nd, EORASS) &&
+ !CTool_EndianReadWord32(&pattern->val14.hi)
+ )
+ {
+ UInt32 tmp = CInt64_GetULong(&pattern->val14);
+ if (
+ (nd->rtype->size == 1 && tmp == 0xFF) ||
+ (nd->rtype->size == 2 && tmp == 0xFFFF) ||
+ (nd->rtype->size == 4 && tmp == 0xFFFFFFFF)
+ )
+ {
+ nd6->nodetype = EASS;
+ }
+ }
+
+ IRO_AddToList(nd7, &list);
+
+ if (IS_LINEAR_MONADIC(pattern->nd10, ETYPCON)) {
+ nd8 = IRO_NewLinear(IROLinearOp1Arg);
+ *nd8 = *pattern->nd10;
+ nd8->index = ++IRO_NumLinear;
+ nd8->u.monadic = nd7;
+ nd8->next = NULL;
+ IRO_AddToList(nd8, &list);
+ } else {
+ nd8 = nd7;
+ }
+ nd6->u.diadic.right = nd8;
+ IRO_AddToList(nd6, &list);
+
+ if (!firstnode)
+ firstnode = list.head;
+ }
+
+ if (nd == lastnd)
+ break;
+ nd = nd->next;
+ }
+
+ if (list.head && list.tail)
+ IRO_Paste(list.head, list.tail, fnode2->last);
+ }
+ } while (++pass < 8);
}
-static void PatternMatchLoop() {
+static int PatternMatchLoop(IRONode *fnode, IROLoop *loop, IROLoopInd *ind, UInt32 *unrollFactor, SInt32 *result1, SInt32 *result2, LoopPattern *pattern) {
+ IROLinear *scan;
+ IROLinear *varnode;
+ IROLinear *nd1;
+ IROLinear *nd2;
+ IROLinear *left1;
+ IROLinear *left2;
+ IROLinear *right1;
+ IROLinear *right2;
+ Object *obj1;
+ Object *obj2;
+ CInt64 shl;
+ CInt64 val;
+
+ *result1 = 0;
+ *result2 = 0;
+
+ if ((scan = fnode->first)) {
+ while (1) {
+ if (
+ (scan->index < loop->index20 || scan->index > loop->index24) &&
+ !(scan->flags & IROLF_Reffed) &&
+ scan->type != IROLinearNop &&
+ scan->type != IROLinearLabel
+ )
+ {
+ if (IS_LINEAR_DIADIC_3(scan, EORASS, EXORASS, EANDASS)) {
+ (*result2)++;
+ if (IS_LINEAR_MONADIC(scan->u.diadic.left, EINDIRECT)) {
+ varnode = scan->u.diadic.left->u.monadic;
+ if (IS_LINEAR_DIADIC(varnode, EADD)) {
+ pattern->nd4 = varnode->u.diadic.left;
+ pattern->type = varnode->rtype;
+ if (IRO_IsVariable(varnode->u.diadic.left)) {
+ pattern->nd0 = varnode->u.diadic.right;
+ if (
+ IS_LINEAR_DIADIC(pattern->nd0, ESHL) &&
+ IRO_IsConstant(pattern->nd0->u.diadic.right)
+ )
+ {
+ pattern->val1C = pattern->nd0->u.diadic.right->u.node->data.intval;
+ nd1 = pattern->nd0->u.diadic.left;
+ } else {
+ return 0;
+ }
+ } else {
+ return 0;
+ }
+ } else {
+ return 0;
+ }
+ } else {
+ return 0;
+ }
+
+ pattern->nd10 = scan->u.diadic.right;
+
+ if (IS_LINEAR_MONADIC(pattern->nd10, ETYPCON)) {
+ if (IS_LINEAR_DIADIC(scan, EANDASS)) {
+ if (IS_LINEAR_MONADIC(pattern->nd10->u.monadic, EBINNOT)) {
+ pattern->ndC = pattern->nd10->u.monadic->u.monadic;
+ } else {
+ return 0;
+ }
+ } else {
+ pattern->ndC = pattern->nd10->u.monadic;
+ }
+
+ if (IS_LINEAR_DIADIC(pattern->ndC, ESHL) && IRO_IsConstant(pattern->ndC->u.diadic.left)) {
+ val = pattern->ndC->u.diadic.left->u.node->data.intval;
+ nd2 = pattern->ndC->u.diadic.right;
+ } else {
+ return 0;
+ }
+ } else if (IS_LINEAR_DIADIC(pattern->nd10, ESHL) && IS_LINEAR_DIADIC_2(scan, EORASS, EXORASS)) {
+ pattern->ndC = pattern->nd10;
+ if (IRO_IsConstant(pattern->ndC->u.diadic.left)) {
+ val = pattern->ndC->u.diadic.left->u.node->data.intval;
+ nd2 = pattern->ndC->u.diadic.right;
+ } else {
+ return 0;
+ }
+ } else if (IS_LINEAR_MONADIC(pattern->nd10, EBINNOT) && IS_LINEAR_DIADIC(scan, EANDASS)) {
+ pattern->ndC = pattern->nd10->u.monadic;
+ if (IS_LINEAR_DIADIC(pattern->ndC, ESHL) && IRO_IsConstant(pattern->ndC->u.diadic.left)) {
+ val = pattern->ndC->u.diadic.left->u.node->data.intval;
+ nd2 = pattern->ndC->u.diadic.right;
+ } else {
+ return 0;
+ }
+ } else {
+ return 0;
+ }
+
+ if (IS_LINEAR_DIADIC(nd2, EAND) && IS_LINEAR_DIADIC(nd1, ESHR)) {
+ left1 = nd1->u.diadic.left;
+ left2 = nd2->u.diadic.left;
+ obj1 = IRO_IsVariable(left1);
+ obj2 = IRO_IsVariable(left2);
+ if (obj1 == obj2 && obj1 == ind->var->object) {
+ right1 = nd1->u.diadic.right;
+ right2 = nd2->u.diadic.right;
+ if (IRO_IsConstant(right1) && IRO_IsConstant(right2)) {
+ shl = cint64_one;
+ shl = CInt64_Shl(shl, right1->u.node->data.intval);
+ shl = CInt64_Sub(shl, cint64_one);
+ if (CInt64_Equal(shl, right2->u.node->data.intval)) {
+ if (CTool_EndianReadWord32(&shl.hi) == 0) {
+ *unrollFactor = CInt64_GetULong(&shl) + 1;
+ if (CheckConstant(CInt64_Add(shl, cint64_one), val, &pattern->val14)) {
+ (*result1)++;
+ if (IS_LINEAR_DIADIC(scan, EANDASS))
+ pattern->val14 = CInt64_Not(pattern->val14);
+ }
+ } else {
+ return 0;
+ }
+ } else {
+ return 0;
+ }
+ } else {
+ return 0;
+ }
+ } else {
+ return 0;
+ }
+ } else {
+ return 0;
+ }
+ } else {
+ return 0;
+ }
+ }
+
+ if (scan == fnode->last)
+ break;
+ scan = scan->next;
+ }
+ }
+
+ return 1;
}
-static void UnrollWhileLoop() {
+static UInt32 UnrollWhileLoop(IRONode *header, IRONode *fnode2, IRONode *fnode3, IROLoop *loop, UInt32 unrollFactor) {
+ IROLoopInd *ind;
+ IRONode *scan;
+ CLabel *lastlabel;
+ IROLinear *lastlabelnode;
+ IROLinear *earlyLoopExitTest;
+ CLabel *earlyLoopExitTestLabel;
+ IROLinear *origIterationCount;
+ IROLinear *unrolledFinalValue;
+ IROLinear *preAlignTemp;
+ IROLinear *newFinalValue;
+ IROLinear *savedHead60;
+ IROLinear *unrolledBodyEntryTest;
+ CLabel *label;
+ IROLinear *savedHead2;
+ IROLinear *loophead25;
+ IROLinear *loopend;
+ IROLinear *loopscan;
+ IROLinear *indvar;
+ IROLinear *less;
+ IROLinear *loopExitTest;
+ IROLinear *saveTail;
+ CLabel *label2;
+ IROLinear *gotond;
+ CLabel *label3;
+ IROLinear *savedHead3;
+ IROLinear *updIndInc;
+ IROLinear *label2nd;
+ IROLinear *less2;
+ IROLinear *saveTail2;
+ IROLinear *less3;
+ IROLinear *wtf;
+ IROLinear *constnd;
+ IROLinear *ass;
+ IROLinear *nd18;
+ IRONode *fn19;
+ IRONode *newfnode1;
+ IRONode *newfnode2;
+ IRONode *newfnode3;
+ IRONode *newfnode4;
+ IRONode *newfnode5;
+ IRONode *newfnode6;
+ IRONode *newfnode7;
+ IRONode *newfnode8;
+ IROLinear *lastnd;
+ ENode *expr;
+ SInt32 result1;
+ SInt32 result2;
+ LoopPattern pattern;
+ IROList list;
+
+ IRO_Dump("while(n--) loop \n");
+
+ if (loop->flags & LoopFlags_800) {
+ IRO_Dump("loop not unrolled because induction used in loop \n");
+ return 0;
+ }
+ if (loop->flags & LoopFlags_1000) {
+ IRO_Dump("loop not unrolled because loop has multiple exits \n");
+ return 0;
+ }
+
+ if (!(loop->flags & LP_HAS_MULTIPLE_INDUCTIONS))
+ return 0;
+
+ for (ind = FirstInd; ind; ind = ind->next) {
+ if ((ind->flags & LoopInd_HasMod) && (ind->flags & LoopInd_HasDiv))
+ break;
+ }
+
+ if (!ind) {
+ IRO_Dump("Could not find loop with and induction with MOD and DIV operation\n");
+ return 0;
+ }
+
+ if (!IRO_IsUnsignedType(ind->nd->rtype))
+ return 0;
+
+ if (ind->nd->type == IROLinearOp2Arg) {
+ if (ind->nd->nodetype == EADDASS && IRO_IsConstant(ind->nd->u.diadic.right)) {
+ if (ind->addConst != 1)
+ return 0;
+ } else if (ind->nd->nodetype == EASS) {
+ if (
+ ind->nd->u.diadic.right->type != IROLinearOp2Arg ||
+ ind->nd->u.diadic.right->nodetype != EADD ||
+ !IRO_IsConstant(ind->nd->u.diadic.right->u.diadic.right)
+ )
+ return 0;
+
+ if (ind->addConst != 1)
+ return 0;
+ } else {
+ return 0;
+ }
+ } else if (ind->nd->type == IROLinearOp1Arg && ind->nd->nodetype != EPREINC && ind->nd->nodetype != EPOSTINC) {
+ return 0;
+ }
+
+ loop->induction = ind;
+ loop->index24 = ind->nd->index;
+ loop->index20 = IRO_FindStart(ind->nd)->index;
+
+ scan = IRO_FirstNode;
+ memset(&pattern, 0, sizeof(pattern));
+ while (scan) {
+ if (Bv_IsBitSet(scan->index, InLoop) && scan != header) {
+ if (!PatternMatchLoop(scan, loop, ind, &unrollFactor, &result1, &result2, &pattern))
+ return 0;
+ }
+ scan = scan->nextnode;
+ }
+
+ if (result1 > 1 || result2 > 1)
+ return 0;
+
+ lastlabel = fnode2->last->u.label.label;
+ lastlabelnode = IRO_FindLabelNode(fnode2->last->u.label.label, fnode2->last);
+
+ IRO_InitList(&list);
+ IRO_DuplicateExprRange(lastlabelnode->next, LoopNode->last->u.label.x4->u.diadic.left, &list);
+ IRO_DuplicateExpr(LoopNode->last->u.label.x4, &list);
+ IRO_Paste(list.head, list.tail, fnode2->last);
+ lastlabelnode = list.tail;
+
+ IRO_InitList(&list);
+ earlyLoopExitTest = BuildEarlyLoopExitTest(LoopNode->last->type, &list);
+ earlyLoopExitTestLabel = IRO_NewLabel();
+ earlyLoopExitTest->u.label.label = earlyLoopExitTestLabel;
+ earlyLoopExitTest->u.label.x4 = lastlabelnode;
+ earlyLoopExitTest->u.label.x4->flags |= IROLF_Reffed;
+ earlyLoopExitTest->rtype = LoopNode->last->rtype;
+ IRO_Paste(list.head, list.tail, fnode2->last);
+
+ IRO_InitList(&list);
+ origIterationCount = BuildOrigIterationCount_DoWhile(&list, loop);
+ IRO_Paste(list.head, list.tail, fnode2->last);
+ savedHead60 = list.head;
+
+ IRO_InitList(&list);
+ preAlignTemp = BuildPreAlignTemp(ind, unrollFactor, &list);
+ IRO_Paste(list.head, list.tail, fnode2->last);
+
+ IRO_InitList(&list);
+ unrolledFinalValue = BuildUnrolledFinalvalue_DoWhile(origIterationCount, unrollFactor, &list, loop);
+ IRO_Paste(list.head, list.tail, fnode2->last);
+
+ IRO_InitList(&list);
+ newFinalValue = BuildNewFinalvalue_DoWhile(origIterationCount, unrollFactor, &list, loop);
+ IRO_Paste(list.head, list.tail, fnode2->last);
+
+ IRO_InitList(&list);
+ BuildUnrolledBodyEntryTest(&list, origIterationCount, unrollFactor, lastlabel);
+ IRO_Paste(list.head, list.tail, fnode2->last);
+ unrolledBodyEntryTest = list.tail;
+
+ IRO_InitList(&list);
+ label = BuildLabel(&list);
+ IRO_Paste(list.head, list.tail, fnode2->last);
+
+ savedHead2 = list.head;
+ loophead25 = NULL;
+ for (scan = fnode3; scan && scan != header; scan = scan->nextnode) {
+ IRO_InitList(&list);
+ loopend = scan->last;
+ loopscan = scan->first;
+ while (1) {
+ if (loopscan->stmt)
+ loopscan->stmt->flags |= StmtFlag_10;
+ if (loopscan->type != IROLinearLabel && !(loopscan->flags & IROLF_Reffed)) {
+ IRO_DuplicateExpr(loopscan, &list);
+ if (!loophead25)
+ loophead25 = list.head;
+ }
+ if (loopscan == loopend)
+ break;
+ loopscan = loopscan->next;
+ }
+
+ if (list.head && list.tail)
+ IRO_Paste(list.head, list.tail, fnode2->last);
+ }
+
+ IRO_InitList(&list);
+
+ if (ind->nd->type == IROLinearOp1Arg)
+ IRO_DuplicateExpr(ind->nd->u.monadic, &list);
+ else
+ IRO_DuplicateExpr(ind->nd->u.diadic.left, &list);
+ list.tail->flags &= ~IROLF_Assigned;
+ indvar = list.tail;
+
+ IRO_DuplicateExpr(preAlignTemp, &list);
+ list.tail->flags &= ~IROLF_Assigned;
+
+ less = IRO_NewLinear(IROLinearOp2Arg);
+ less->nodetype = ELESS;
+ less->rtype = TYPE(&stbool);
+ less->index = ++IRO_NumLinear;
+ less->next = NULL;
+ less->u.diadic.left = indvar;
+ less->u.diadic.right = list.tail;
+ IRO_AddToList(less, &list);
+ less->flags |= IROLF_Reffed;
+
+ loopExitTest = BuildLoopExitTest(LoopNode->last->type, &list);
+ loopExitTest->u.label.label = label;
+ loopExitTest->u.label.x4 = less;
+ loopExitTest->u.label.x4->flags |= IROLF_Reffed;
+ loopExitTest->rtype = LoopNode->last->rtype;
+ IRO_Paste(list.head, list.tail, fnode2->last);
+ saveTail = list.tail;
+
+ IRO_InitList(&list);
+ label2 = IRO_NewLabel();
+ gotond = IRO_NewLinear(IROLinearOp1Arg);
+ gotond->index = ++IRO_NumLinear;
+ gotond->type = IROLinearGoto;
+ gotond->u.label.label = label2;
+ IRO_AddToList(gotond, &list);
+ IRO_Paste(list.head, list.tail, fnode2->last);
+
+ IRO_InitList(&list);
+ label3 = BuildLabel(&list);
+ IRO_Paste(list.head, list.tail, fnode2->last);
+ savedHead3 = list.head;
+
+ UnrollWhileLoopBody(header, fnode2, fnode3, loop, &pattern, unrollFactor);
+ updIndInc = UpdateInductionIncrement(loop, 8 * unrollFactor, fnode2->last);
+
+ IRO_InitList(&list);
+ label2nd = IRO_NewLinear(IROLinearLabel);
+ label2nd->index = IRO_NumLinear++;
+ label2nd->u.label.label = label2;
+ label2nd->flags |= IROLF_1;
+ IRO_AddToList(label2nd, &list);
+ IRO_Paste(list.head, list.tail, fnode2->last);
+
+ IRO_InitList(&list);
+
+ if (ind->nd->type == IROLinearOp1Arg)
+ IRO_DuplicateExpr(ind->nd->u.monadic, &list);
+ else
+ IRO_DuplicateExpr(ind->nd->u.diadic.left, &list);
+ list.tail->flags &= ~IROLF_Assigned;
+ indvar = list.tail;
+
+ IRO_DuplicateExpr(unrolledFinalValue, &list);
+ list.tail->flags &= ~IROLF_Assigned;
+
+ less2 = IRO_NewLinear(IROLinearOp2Arg);
+ less2->nodetype = ELESS;
+ less2->rtype = TYPE(&stbool);
+ less2->index = ++IRO_NumLinear;
+ less2->next = NULL;
+ less2->u.diadic.left = indvar;
+ less2->u.diadic.right = list.tail;
+ IRO_AddToList(less2, &list);
+ less2->flags |= IROLF_Reffed;
+
+ loopExitTest = BuildLoopExitTest(LoopNode->last->type, &list);
+ loopExitTest->u.label.label = label3;
+ loopExitTest->u.label.x4 = less2;
+ loopExitTest->u.label.x4->flags |= IROLF_Reffed;
+ loopExitTest->rtype = LoopNode->last->rtype;
+ IRO_Paste(list.head, list.tail, fnode2->last);
+ saveTail2 = list.tail;
+
+ IRO_InitList(&list);
+
+ if (ind->nd->type == IROLinearOp1Arg)
+ IRO_DuplicateExpr(ind->nd->u.monadic, &list);
+ else
+ IRO_DuplicateExpr(ind->nd->u.diadic.left, &list);
+ list.tail->flags &= ~IROLF_Assigned;
+ indvar = list.tail;
+
+ IRO_DuplicateExpr(newFinalValue, &list);
+ list.tail->flags &= ~IROLF_Assigned;
+
+ less3 = IRO_NewLinear(IROLinearOp2Arg);
+ less3->nodetype = ELESS;
+ less3->rtype = TYPE(&stbool);
+ less3->index = ++IRO_NumLinear;
+ less3->next = NULL;
+ less3->u.diadic.left = indvar;
+ less3->u.diadic.right = list.tail;
+ IRO_AddToList(less3, &list);
+ less3->flags |= IROLF_Reffed;
+
+ wtf = LoopNode->last->u.label.x4;
+ IRO_Paste(list.head, list.tail, LoopNode->last);
+ LoopNode->last->u.label.x4 = list.tail;
+
+ IRO_InitList(&list);
+
+ constnd = IRO_NewLinear(IROLinearOperand);
+ constnd->index = ++IRO_NumLinear;
+ expr = IRO_NewENode(EINTCONST);
+ expr->rtype = wtf->u.diadic.left->rtype;
+ expr->data.intval = cint64_zero;
+ constnd->u.node = expr;
+ constnd->rtype = expr->rtype;
+ IRO_AddToList(constnd, &list);
+ constnd->flags |= IROLF_Reffed;
+
+ IRO_DuplicateExpr(wtf->u.diadic.left, &list);
+
+ ass = IRO_NewLinear(IROLinearOp2Arg);
+ ass->nodetype = EASS;
+ ass->rtype = list.tail->rtype;
+ ass->index = ++IRO_NumLinear;
+ ass->next = NULL;
+ ass->u.diadic.left = list.tail;
+ ass->u.diadic.right = constnd;
+ IRO_AddToList(ass, &list);
+ ass->flags |= IROLF_Assigned;
+
+ IRO_NopOut(wtf);
+
+ fn19 = fnode2->nextnode;
+ nd18 = fnode2->last;
+ fnode2->last = earlyLoopExitTest;
+
+ newfnode1 = IRO_NewFlowGraphNode();
+ newfnode1->first = savedHead60;
+ newfnode1->last = unrolledBodyEntryTest;
+ fnode2->nextnode = newfnode1;
+
+ newfnode2 = IRO_NewFlowGraphNode();
+ newfnode2->first = savedHead2;
+ newfnode2->last = saveTail;
+ savedHead2->u.label.label->stmt = (Statement *) newfnode2;
+ newfnode1->nextnode = newfnode2;
+
+ newfnode3 = IRO_NewFlowGraphNode();
+ newfnode3->first = gotond;
+ newfnode3->last = gotond;
+ newfnode2->nextnode = newfnode3;
+
+ newfnode4 = IRO_NewFlowGraphNode();
+ newfnode4->first = savedHead3;
+ newfnode4->last = updIndInc;
+ savedHead3->u.label.label->stmt = (Statement *) newfnode4;
+ newfnode3->nextnode = newfnode4;
+
+ newfnode5 = IRO_NewFlowGraphNode();
+ newfnode5->first = label2nd;
+ newfnode5->last = saveTail2;
+ label2nd->u.label.label->stmt = (Statement *) newfnode5;
+ newfnode4->nextnode = newfnode5;
+
+ newfnode6 = IRO_NewFlowGraphNode();
+ newfnode6->first = nd18;
+ newfnode6->last = nd18;
+ newfnode5->nextnode = newfnode6;
+ newfnode6->nextnode = fn19;
+
+ newfnode7 = oalloc(sizeof(IRONode));
+ memset(newfnode7, 0, sizeof(IRONode));
+ newfnode7->index = IRO_NumNodes;
+ IRO_NumNodes++;
+
+ newfnode7->first = list.head;
+ newfnode7->last = list.tail;
+
+ list.tail->next = LoopNode->last->next;
+ LoopNode->last->next = list.head;
+
+ newfnode7->nextnode = LoopNode->nextnode;
+ LoopNode->nextnode = newfnode7;
+
+ newfnode8 = oalloc(sizeof(IRONode));
+ memset(newfnode8, 0, sizeof(IRONode));
+ newfnode8->index = IRO_NumNodes;
+ IRO_NumNodes++;
+
+ lastnd = IRO_NewLinear(IROLinearLabel);
+ lastnd->index = IRO_NumLinear++;
+ lastnd->next = NULL;
+ lastnd->u.label.label = earlyLoopExitTestLabel;
+ lastnd->flags |= IROLF_1;
+ earlyLoopExitTestLabel->stmt = (Statement *) newfnode8;
+
+ newfnode8->first = lastnd;
+ newfnode8->last = lastnd;
+
+ lastnd->next = newfnode7->last->next;
+ newfnode7->last->next = lastnd;
+
+ newfnode8->nextnode = newfnode7->nextnode;
+ newfnode7->nextnode = newfnode8;
+
+ return 1;
}
-void IRO_IterateForLoopBody() {
+void IRO_IterateForLoopBody(IRONode *start, IRONode *end, IROLoop *loop, IROLinear *destnode, SInt32 addConst, CInt64 *val, Boolean funkyFlag) {
+ IROLinear *first = NULL;
+ IROLinear *last = NULL;
+ IRONode *fnode;
+ IROLinear *lastnd;
+ IROLinear *nd;
+ IROList list;
+
+ for (fnode = start; fnode && fnode != end; fnode = fnode->nextnode) {
+ IRO_InitList(&list);
+
+ lastnd = fnode->last;
+ nd = fnode->first;
+ while (1) {
+ if (nd->stmt)
+ nd->stmt->flags |= StmtFlag_10;
+
+ if (
+ (nd->index < loop->index20 || nd->index > loop->index24) &&
+ nd->type != IROLinearLabel &&
+ !(nd->flags & IROLF_Reffed)
+ )
+ {
+ IRO_DuplicateExpr(nd, &list);
+ if (!first)
+ first = list.head;
+ last = list.tail;
+ }
+
+ if (nd == lastnd)
+ break;
+ nd = nd->next;
+ }
+
+ if (list.head && list.tail)
+ IRO_Paste(list.head, list.tail, destnode);
+ }
+
+ if (funkyFlag) {
+ *val = CInt64_Add(*val, IRO_MakeLong(loop->induction->addConst));
+ ChangeInductionReference(first, last, *val, loop);
+ }
}
-void IRO_LinearizeForLoopPostLoop() {
+void IRO_LinearizeForLoopPostLoop(IRONode *fnode1, IRONode *fnode2, IROLoop *loop, IRONode *fnode3, UInt32 unrollFactor) {
+ IRONode *newfnode;
+ IROLinear *newnd;
+ SInt32 i;
+ CInt64 val;
+
+ newfnode = oalloc(sizeof(IRONode));
+ memset(newfnode, 0, sizeof(IRONode));
+ newfnode->index = IRO_NumNodes;
+ IRO_NumNodes++;
+
+ newnd = IRO_NewLinear(IROLinearNop);
+ newnd->index = IRO_NumLinear++;
+ newnd->next = NULL;
+ newnd->flags |= IROLF_1;
+
+ newfnode->first = newfnode->last = newnd;
+
+ newfnode->nextnode = fnode3->nextnode;
+ fnode3->nextnode = newfnode;
+
+ newnd->next = fnode3->last->next;
+ fnode3->last->next = newnd;
+
+ val = cint64_zero;
+ for (i = 0; i < unrollFactor; i++)
+ IRO_IterateForLoopBody(fnode2, fnode1, loop, newfnode->last, loop->induction->addConst, &val, i > 0);
+ UpdateInductionIncrement(loop, unrollFactor, newfnode->last);
}
-static void UnrollForLoop() {
+static UInt32 UnrollForLoop(IRONode *header, IRONode *fnode2, IRONode *fnode3, IROLoop *loop, UInt32 unrollFactor) {
+ IROLinear *lastlabelnode;
+ IROLinear *earlyLoopExitTest;
+ IROLinear *origIterationCount;
+ IROLinear *saveHead1;
+ IROLinear *newFinalValue;
+ IROLinear *unrolledBodyEntryTest;
+ IROLinear *gotoNd;
+ IROLinear *saveHead2;
+ IROLinear *updIndInc;
+ IROLinear *labelNd;
+ IROLinear *saveTail2;
+ IROLinear *ndCopy;
+ IROLinear *saveTail3;
+ IROLinear *loopExitTest;
+ IROLinear *lastnd;
+ IROLinear *labelNd2;
+ IROLinear *saveTail4;
+ IROLinear *labelNd3;
+ IROLinear *scan;
+ IRONode *nd18;
+ IRONode *newfnode1;
+ IRONode *newfnode2;
+ IRONode *newfnode3;
+ IRONode *newfnode4;
+ IRONode *newfnode5;
+ IRONode *newfnode6;
+ CLabel *lastlabel;
+ CLabel *earlyLoopExitTestLabel;
+ CLabel *label;
+ CLabel *label2;
+ SInt32 i;
+
+ IROList list;
+ CInt64 iterCount;
+ int isConstant;
+ UInt32 needOrigLoop = 0;
+ UInt32 needUnrollBodyTest = 0;
+ UInt32 resetUnrolledFinalValue = 0;
+ SInt32 leftOver;
+ CInt64 val;
+
+ lastlabelnode = IRO_FindLabelNode(fnode2->last->u.label.label, fnode2->last);
+ lastlabel = IRO_NewLabel();
+
+ IRO_InitList(&list);
+ IRO_DuplicateExprRange(lastlabelnode->next, LoopNode->last->u.label.x4, &list);
+ IRO_DuplicateExpr(LoopNode->last->u.label.x4, &list);
+ IRO_Paste(list.head, list.tail, fnode2->last);
+ lastlabelnode = list.tail;
+
+ IRO_InitList(&list);
+ earlyLoopExitTest = BuildEarlyLoopExitTest(LoopNode->last->type, &list);
+ earlyLoopExitTestLabel = IRO_NewLabel();
+ earlyLoopExitTest->u.label.label = earlyLoopExitTestLabel;
+ earlyLoopExitTest->u.label.x4 = lastlabelnode;
+ earlyLoopExitTest->u.label.x4->flags |= IROLF_Reffed;
+ earlyLoopExitTest->rtype = LoopNode->last->rtype;
+ IRO_Paste(list.head, list.tail, fnode2->last);
+
+ isConstant = IsIterationCountConstant(loop, &iterCount);
+ needOrigLoop = 1;
+ needUnrollBodyTest = 1;
+ resetUnrolledFinalValue = 0;
+ if (isConstant)
+ IRO_TestConstantIterationCount(loop, &iterCount, 1, &unrollFactor, &leftOver, &needOrigLoop, &needUnrollBodyTest, &resetUnrolledFinalValue);
+
+ IRO_InitList(&list);
+ origIterationCount = BuildOrigIterationCount(&list, loop);
+ IRO_Paste(list.head, list.tail, fnode2->last);
+ saveHead1 = list.head;
+
+ IRO_InitList(&list);
+ newFinalValue = BuildNewFinalvalue(origIterationCount, unrollFactor, &list, loop);
+ IRO_Paste(list.head, list.tail, fnode2->last);
+
+ IRO_InitList(&list);
+ BuildUnrolledBodyEntryTest(&list, origIterationCount, unrollFactor, lastlabel);
+ IRO_Paste(list.head, list.tail, fnode2->last);
+ unrolledBodyEntryTest = list.tail;
+
+ label = IRO_NewLabel();
+ IRO_InitList(&list);
+ gotoNd = IRO_NewLinear(IROLinearOp1Arg);
+ gotoNd->index = ++IRO_NumLinear;
+ gotoNd->type = IROLinearGoto;
+ gotoNd->u.label.label = label;
+ IRO_AddToList(gotoNd, &list);
+ IRO_Paste(list.head, list.tail, fnode2->last);
+
+ IRO_InitList(&list);
+ label2 = BuildLabel(&list);
+ IRO_Paste(list.head, list.tail, fnode2->last);
+ saveHead2 = list.head;
+
+ val = cint64_zero;
+ for (i = 0; i < unrollFactor; i++)
+ IRO_IterateForLoopBody(fnode3, header, loop, fnode2->last, loop->induction->addConst, &val, i > 0);
+ updIndInc = UpdateInductionIncrement(loop, unrollFactor, fnode2->last);
+
+ IRO_InitList(&list);
+ labelNd = IRO_NewLinear(IROLinearLabel);
+ labelNd->index = IRO_NumLinear++;
+ labelNd->u.label.label = label;
+ labelNd->flags |= IROLF_1;
+ IRO_AddToList(labelNd, &list);
+ IRO_Paste(list.head, list.tail, fnode2->last);
+
+ IRO_InitList(&list);
+
+ IRO_DuplicateExpr(LoopNode->last->u.label.x4->u.diadic.left, &list);
+ saveTail2 = list.tail;
+
+ if (resetUnrolledFinalValue)
+ IRO_DuplicateExpr(loop->nd18->u.diadic.right, &list);
+ else
+ IRO_DuplicateExpr(newFinalValue, &list);
+
+ ndCopy = IRO_NewLinear(LoopNode->last->u.label.x4->type);
+ *ndCopy = *LoopNode->last->u.label.x4;
+ ndCopy->index = ++IRO_NumLinear;
+ ndCopy->next = NULL;
+ ndCopy->expr = NULL;
+ ndCopy->u.diadic.left = saveTail2;
+ ndCopy->u.diadic.right = list.tail;
+ IRO_AddToList(ndCopy, &list);
+
+ IRO_Paste(list.head, list.tail, fnode2->last);
+ saveTail3 = list.tail;
+
+ IRO_InitList(&list);
+ loopExitTest = BuildLoopExitTest(LoopNode->last->type, &list);
+ loopExitTest->u.label.label = label2;
+ loopExitTest->u.label.x4 = saveTail3;
+ loopExitTest->u.label.x4->flags |= IROLF_Reffed;
+ loopExitTest->rtype = LoopNode->last->rtype;
+ IRO_Paste(list.head, list.tail, fnode2->last);
+ saveTail4 = list.tail;
+
+ IRO_InitList(&list);
+ labelNd2 = IRO_NewLinear(IROLinearLabel);
+ labelNd2->index = IRO_NumLinear++;
+ labelNd2->u.label.label = lastlabel;
+ labelNd2->flags |= IROLF_1;
+ IRO_AddToList(labelNd2, &list);
+ IRO_Paste(list.head, list.tail, fnode2->last);
+
+ lastnd = fnode2->last;
+ nd18 = fnode2->nextnode;
+ fnode2->last = earlyLoopExitTest;
+
+ newfnode1 = IRO_NewFlowGraphNode();
+ newfnode1->first = saveHead1;
+ newfnode1->last = unrolledBodyEntryTest;
+ fnode2->nextnode = newfnode1;
+
+ newfnode2 = IRO_NewFlowGraphNode();
+ newfnode2->first = gotoNd;
+ newfnode2->last = gotoNd;
+ newfnode1->nextnode = newfnode2;
+
+ newfnode3 = IRO_NewFlowGraphNode();
+ newfnode3->first = saveHead2;
+ newfnode3->last = updIndInc;
+
+ saveHead2->u.label.label->stmt = (Statement *) newfnode3;
+ if (newfnode2)
+ newfnode2->nextnode = newfnode3;
+ else
+ newfnode1->nextnode = newfnode3;
+
+ newfnode4 = IRO_NewFlowGraphNode();
+ newfnode4->first = labelNd;
+ newfnode4->last = saveTail4;
+ labelNd->u.label.label->stmt = (Statement *) newfnode4;
+ newfnode3->nextnode = newfnode4;
+
+ newfnode5 = IRO_NewFlowGraphNode();
+ newfnode5->first = labelNd2;
+ newfnode5->last = lastnd;
+ newfnode4->nextnode = newfnode5;
+ newfnode5->nextnode = nd18;
+
+ newfnode6 = oalloc(sizeof(IRONode));
+ memset(newfnode6, 0, sizeof(IRONode));
+ newfnode6->index = IRO_NumNodes;
+ IRO_NumNodes++;
+
+ labelNd3 = IRO_NewLinear(IROLinearLabel);
+ labelNd3->index = IRO_NumLinear++;
+ labelNd3->next = NULL;
+ labelNd3->u.label.label = earlyLoopExitTestLabel;
+ labelNd3->flags |= IROLF_1;
+ earlyLoopExitTestLabel->stmt = (Statement *) newfnode6;
+
+ newfnode6->first = labelNd3;
+ newfnode6->last = labelNd3;
+
+ labelNd3->next = LoopNode->last->next;
+ LoopNode->last->next = labelNd3;
+
+ newfnode6->nextnode = LoopNode->nextnode;
+ LoopNode->nextnode = newfnode6;
+
+ if (!needOrigLoop) {
+ NoOpBlock(newfnode5);
+ NoOpBlock(header);
+ NoOpBlock(fnode3);
+ NoOpBlock(loop->induction->fnode);
+ IRO_NopOut(newfnode1->last->u.label.x4);
+ newfnode1->last->type = IROLinearNop;
+ }
+
+ if (!needUnrollBodyTest) {
+ IRO_NopOut(earlyLoopExitTest->u.label.x4);
+ earlyLoopExitTest->type = IROLinearNop;
+
+ IRO_NopOut(newfnode4->last->u.label.x4);
+ newfnode4->last->type = IROLinearNop;
+
+ if (newfnode2)
+ newfnode2->last->type = IROLinearNop;
+
+ for (scan = newfnode1->first; scan; scan = scan->next) {
+ if (!(scan->flags & IROLF_Reffed))
+ IRO_NopOut(scan);
+ if (scan == newfnode1->last)
+ break;
+ }
+ }
+
+ return 1;
}
-static void UnrollStandardLoop() {
+static UInt32 UnrollStandardLoop(IRONode *header, IRONode *fnode2, IRONode *fnode3, int count) {
+ IROLoop *loop;
+
+ ConditionalHeaderAtBottom = 1;
+ loop = ExtractLoopInfo(header);
+ loop->xC = fnode2;
+ loop->x10 = fnode3;
+ FindAssignmenttoInductionVar(loop, fnode2);
+
+ if (!IsLoopUnrollable(loop)) {
+ IRO_Dump("LoopUnroll:loop with header %d not unrolled because IsLoopUnrollable failed\n", header->index);
+ return 0;
+ }
+
+ if (loop->flags & LoopFlags_10000)
+ return UnrollWhileLoop(header, fnode2, fnode3, loop, count);
+ else
+ return UnrollForLoop(header, fnode2, fnode3, loop, count);
}
-static void LoopUnroll() {
+static void LoopUnroll(int count, IRONode *header) {
+ VarRecord *var;
+ IRONode *tmp;
+ UInt16 i;
+ UInt16 j;
+ IRONode *prevpred;
+ IRONode *prevsucc;
+ int foundpred;
+ UInt32 predcount;
+ UInt32 success = 0;
+
+ LoopNode = header;
+ FindMustReach();
+
+ for (var = IRO_FirstVar; var; var = var->next)
+ var->xA = 1;
+
+ ComputeLoopKills();
+ ComputeLoopInvariance();
+ ComputeLoopInduction();
+
+ LoopNode = header;
+ ConditionalHeaderAtBottom = 0;
+
+ prevpred = NULL;
+ foundpred = 0;
+ for (i = 0; i < LoopNode->numpred; i++) {
+ tmp = IRO_NodeTable[LoopNode->pred[i]];
+ if (!Bv_IsBitSet(tmp->index, InLoop)) {
+ foundpred = 1;
+ if (tmp->nextnode == header) {
+ CError_ASSERT(2101, !prevpred || tmp == prevpred);
+ prevpred = tmp;
+ }
+ }
+ }
+
+ if (!foundpred) {
+ IRO_Dump("No predecessor outside the loop\n");
+ return;
+ }
+
+ if (LoopNode->last->type == IROLinearIf || LoopNode->last->type == IROLinearIfNot) {
+ if (LoopNode->nextnode && !Bv_IsBitSet(LoopNode->nextnode->index, InLoop)) {
+ prevsucc = NULL;
+ for (i = 0; i < LoopNode->numsucc; i++) {
+ tmp = IRO_NodeTable[LoopNode->succ[i]];
+ if (Bv_IsBitSet(tmp->index, InLoop)) {
+ CError_ASSERT(2159, !prevsucc);
+ prevsucc = tmp;
+ }
+ }
+
+ prevpred = NULL;
+ predcount = 0;
+ for (j = 0; j < LoopNode->numpred; j++) {
+ tmp = IRO_NodeTable[LoopNode->pred[j]];
+ if (!Bv_IsBitSet(tmp->index, InLoop)) {
+ prevpred = tmp;
+ predcount++;
+ }
+ }
+
+ if (
+ predcount == 1 &&
+ prevpred->last->type == IROLinearGoto &&
+ prevpred->nextnode == prevsucc &&
+ prevsucc != LoopNode
+ )
+ {
+ success = UnrollStandardLoop(header, prevpred, prevsucc, count);
+ }
+ }
+ } else {
+ IRO_Dump(" LoopUnroll:Loop with header = %d is not a conditional loop\n", header->index);
+ }
+
+ if (!success)
+ return;
+
+ IRO_NodeTable = oalloc(sizeof(IRONode *) * IRO_NumNodes);
+ memset(IRO_NodeTable, 0, sizeof(IRONode *) * IRO_NumNodes);
+ for (tmp = IRO_FirstNode; tmp; tmp = tmp->nextnode)
+ IRO_NodeTable[tmp->index] = tmp;
+ IRO_ComputeSuccPred();
+ IRO_ComputeDom();
+ if (success)
+ IRO_Dump(" LoopUnroll:Loop with header = %d Unrolled\n", header->index);
}
-static void IsLoopUnrollable() {
+static int IsLoopUnrollable(IROLoop *loop) {
+ CInt64 tmp;
+
+ if (loop->flags & LP_LOOP_HAS_ASM) {
+ IRO_Dump("IsLoopUnrollable:No due to LP_LOOP_HAS_ASM \n");
+ return 0;
+ }
+ if (loop->flags & LP_IFEXPR_NON_CANONICAL) {
+ IRO_Dump("IsLoopUnrollable:No due to LP_IFEXPR_NON_CANONICAL \n");
+ return 0;
+ }
+ if (loop->flags & LP_LOOP_HAS_CALLS) {
+ IRO_Dump("IsLoopUnrollable:No due to LP_LOOP_HAS_CALLS \n");
+ return 0;
+ }
+ if (loop->flags & LP_LOOP_HAS_CNTRLFLOW) {
+ IRO_Dump("IsLoopUnrollable:No due to LP_LOOP_HAS_CNTRLFLOW \n");
+ return 0;
+ }
+ if (loop->flags & LP_INDUCTION_NOT_FOUND) {
+ IRO_Dump("IsLoopUnrollable:No due to LP_INDUCTION_NOT_FOUND \n");
+ return 0;
+ }
+ if (loop->flags & LP_LOOP_HDR_HAS_SIDEEFFECTS) {
+ IRO_Dump("IsLoopUnrollable:No due to LP_LOOP_HDR_HAS_SIDEEFFECTS \n");
+ return 0;
+ }
+ if (!(loop->flags & LoopFlags_200)) {
+ IRO_Dump("IsLoopUnrollable:No because header does not follow induction update \n");
+ return 0;
+ }
+
+ if (!(loop->flags & LoopFlags_10000)) {
+ IROLinear *upperBound = loop->nd18->u.diadic.right;
+ if (!IRO_IsIntConstant(upperBound) && !(upperBound->flags & IROLF_LoopInvariant)) {
+ IRO_Dump("IsLoopUnrollable:No because Loop Upper Bound is Variant in the loop\n");
+ return 0;
+ }
+ if (!loop->nd14) {
+ IRO_Dump("IsLoopUnrollable:No because there is no initialization of loop index in PreHeader\n");
+ return 0;
+ }
+ if (!IRO_IsVariable(loop->nd14->u.diadic.left)) {
+ IRO_Dump("IsLoopUnrollable:No because initial value of induction stored thru pointer\n");
+ return 0;
+ }
+
+ if (!IRO_IsUnsignedType(loop->nd14->rtype)) {
+ if (IRO_IsIntConstant(loop->nd14->u.diadic.right)) {
+ if (!CInt64_GreaterEqual(loop->nd14->u.diadic.right->u.node->data.intval, cint64_zero)) {
+ IRO_Dump("IsLoopUnrollable:No because initial value of induction is signed but init < 0\n");
+ return 0;
+ }
+ } else if (IsIterationCountConstant(loop, &tmp)) {
+ IRO_Dump("IsLoopUnrollable:Yes, the limits substract out to be constants\n");
+ } else {
+ IRO_Dump("IsLoopUnrollable:No because initial value of induction is signed and not constant\n");
+ return 0;
+ }
+ }
+
+ if (!(loop->flags & LP_LOOP_STEP_ISADD)) {
+ IRO_Dump("IsLoopUnrollable:No because LP_LOOP_STEP_ISADD is not set i.e induciton is not updated by 1\n");
+ return 0;
+ }
+
+ } else {
+ if (!IRO_IsUnsignedType(loop->nd18->u.diadic.left->rtype)) {
+ IRO_Dump("IsLoopUnrollable:No because the while loop induction is signed\n");
+ return 0;
+ }
+ if (!(loop->flags & LoopFlags_2000)) {
+ IRO_Dump("IsLoopUnrollable:No because the while loop operator is not of decrement form\n");
+ return 0;
+ }
+ }
+
+ if (loop->sizeBySomeMeasurement > copts.loop_unroll_size_threshold) {
+ IRO_Dump("IsLoopUnrollable:No because loop size greater than threshold\n");
+ return 0;
+ }
+
+ return 1;
}
-void BuildEarlyLoopExitTest() {
+IROLinear *BuildEarlyLoopExitTest(IROLinearType type, IROList *list) {
+ IROLinear *nd = IRO_NewLinear(IROLinearOp1Arg);
+ nd->index = ++IRO_NumLinear;
+ if (type == IROLinearIf)
+ nd->type = IROLinearIfNot;
+ else
+ nd->type = IROLinearIf;
+ IRO_AddToList(nd, list);
+ return nd;
}
-void BuildLoopExitTest() {
+IROLinear *BuildLoopExitTest(IROLinearType type, IROList *list) {
+ IROLinear *nd = IRO_NewLinear(IROLinearOp1Arg);
+ nd->index = ++IRO_NumLinear;
+ nd->type = type;
+ IRO_AddToList(nd, list);
+ return nd;
}
-void IsIterationCountConstant() {
+int IsIterationCountConstant(IROLoop *loop, CInt64 *pval) {
+ IROLinear *lowerBound;
+ IROLinear *upperBound;
+ Type *type;
+ int isUnsigned;
+ IROAddrRecord *lowerRec;
+ IROAddrRecord *upperRec;
+ CInt64 lowerval;
+ CInt64 upperval;
+ CInt64 incval;
+ CInt64 negOne;
+
+ lowerBound = loop->nd14->u.diadic.right;
+ if (loop->flags & LoopFlags_1) {
+ upperBound = loop->nd18->u.diadic.right;
+ type = loop->nd18->u.diadic.right->rtype;
+ } else {
+ upperBound = loop->nd18->u.diadic.left;
+ type = loop->nd18->u.diadic.left->rtype;
+ }
+
+ isUnsigned = IRO_IsUnsignedType(type);
+
+ if (IRO_IsIntConstant(lowerBound) && IRO_IsIntConstant(upperBound)) {
+ lowerval = lowerBound->u.node->data.intval;
+ upperval = upperBound->u.node->data.intval;
+ if (isUnsigned) {
+ if (CInt64_LessEqualU(upperval, lowerval))
+ return 0;
+ } else {
+ if (CInt64_LessEqual(upperval, lowerval))
+ return 0;
+ }
+
+ CInt64_SetLong(&incval, loop->induction->addConst);
+ CInt64_SetLong(&negOne, -1);
+ *pval = CInt64_Sub(upperval, lowerval);
+ *pval = CInt64_Add(*pval, incval);
+
+ if (IS_LINEAR_DIADIC(loop->nd18, ELESS))
+ *pval = CInt64_Add(*pval, negOne);
+
+ CError_ASSERT(2486, !CInt64_IsZero(&incval));
+
+ if (isUnsigned)
+ *pval = CInt64_DivU(*pval, incval);
+ else
+ *pval = CInt64_Div(*pval, incval);
+
+ if (CInt64_Equal(*pval, cint64_zero))
+ return 0;
+
+ if (isUnsigned) {
+ CError_ASSERT(2508, !CInt64_LessEqualU(*pval, cint64_zero));
+ } else {
+ CError_ASSERT(2517, !CInt64_LessEqual(*pval, cint64_zero));
+ }
+
+ return 1;
+ }
+
+ lowerRec = IRO_InitAddrRecordPointer(lowerBound);
+ upperRec = IRO_InitAddrRecordPointer(upperBound);
+
+ if (IS_LINEAR_DIADIC(lowerBound, EADD)) {
+ IRO_DecomposeAddressExpression(lowerBound, lowerRec);
+ } else if (IRO_IsIntConstant(lowerBound)) {
+ lowerRec->numInts++;
+ IRO_AddElmToList(lowerBound, &lowerRec->ints);
+ lowerRec->numObjRefs = 0;
+ lowerRec->numMisc = 0;
+ } else {
+ lowerRec->numMisc++;
+ IRO_AddElmToList(lowerBound, &lowerRec->misc);
+ lowerRec->numObjRefs = 0;
+ lowerRec->numInts = 0;
+ }
+
+ if (IS_LINEAR_DIADIC(upperBound, EADD)) {
+ IRO_DecomposeAddressExpression(upperBound, upperRec);
+ } else if (IRO_IsIntConstant(upperBound)) {
+ upperRec->numInts++;
+ IRO_AddElmToList(upperBound, &upperRec->ints);
+ upperRec->numObjRefs = 0;
+ upperRec->numMisc = 0;
+ } else {
+ upperRec->numMisc++;
+ IRO_AddElmToList(upperBound, &upperRec->misc);
+ upperRec->numObjRefs = 0;
+ upperRec->numInts = 0;
+ }
+
+ if (IsDifferenceOfTermsConstant(lowerRec, upperRec, isUnsigned, pval)) {
+ if (IS_LINEAR_DIADIC(loop->nd18, ELESSEQU))
+ *pval = CInt64_Add(*pval, cint64_one);
+ return 1;
+ }
+
+ return 0;
}
-static void IsDifferenceOfTermsConstant() {
+static int IsDifferenceOfTermsConstant(IROAddrRecord *lowerRec, IROAddrRecord *upperRec, int isUnsigned, CInt64 *pval) {
+ UInt32 i;
+ CInt64 upperval;
+ CInt64 lowerval;
+ IROElmList *el;
+ IROLinear *nd;
+
+ if (upperRec->numObjRefs == lowerRec->numObjRefs && upperRec->numObjRefs != 0)
+ return 0;
+ else if (upperRec->numObjRefs != lowerRec->numObjRefs)
+ return 0;
+
+ if (upperRec->numMisc == lowerRec->numMisc && upperRec->numMisc != 0) {
+ for (i = 0; i < upperRec->numMisc; i++) {
+ // bug? surely this should index on i...?
+ if (!IRO_ExprsSame(lowerRec->misc->element, upperRec->misc->element))
+ return 0;
+ }
+ } else if (upperRec->numMisc != lowerRec->numMisc) {
+ return 0;
+ }
+
+ upperval = cint64_zero;
+ for (el = upperRec->ints; el; el = el->next) {
+ nd = el->element;
+ upperval = CMach_CalcIntDiadic(nd->rtype, upperval, '+', nd->u.node->data.intval);
+ }
+
+ lowerval = cint64_zero;
+ for (el = lowerRec->ints; el; el = el->next) {
+ nd = el->element;
+ lowerval = CMach_CalcIntDiadic(nd->rtype, lowerval, '+', nd->u.node->data.intval);
+ }
+
+ if (CInt64_Equal(upperval, lowerval))
+ return 0;
+
+ if (CInt64_Greater(upperval, lowerval)) {
+ *pval = CInt64_Sub(upperval, lowerval);
+ return 1;
+ } else {
+ return 0;
+ }
}
-void NoOpBlock() {
+void NoOpBlock(IRONode *fnode) {
+ IROLinear *last, *scan;
+
+ for (scan = fnode->first, last = fnode->last; scan; scan = scan->next) {
+ scan->type = IROLinearNop;
+ if (scan == last)
+ break;
+ }
}
-void IRO_TestConstantIterationCount() {
+void IRO_TestConstantIterationCount(IROLoop *loop, CInt64 *iterCount, SInt32 vectorStride, UInt32 *unrollFactor, SInt32 *leftOver, UInt32 *needOrigLoop, UInt32 *needUnrollBodyTest, UInt32 *resetUnrolledFinalValue) {
+ UInt32 isUnsigned;
+ CInt64 val;
+ CInt64 val3;
+ CInt64 mod;
+ CInt64 val2;
+ CInt64 loopvar3;
+ CInt64 loopvar1;
+ CInt64 loopvar2;
+ CInt64 strideVal;
+
+ CError_ASSERT(2737, *unrollFactor);
+
+ isUnsigned = IRO_IsUnsignedType(
+ (loop->flags & LoopFlags_1) ? loop->nd18->u.diadic.right->rtype :loop->nd18->u.diadic.left->rtype);
+
+ CError_ASSERT(2756, vectorStride);
+
+ strideVal = IRO_MakeLong(vectorStride);
+ if (isUnsigned ? CInt64_LessU(*iterCount, strideVal) : CInt64_Less(*iterCount, strideVal)) {
+ *needOrigLoop = 1;
+ *needUnrollBodyTest = 0;
+ *unrollFactor = 0;
+ *leftOver = CInt64_GetULong(iterCount);
+ } else {
+ switch (vectorStride) {
+ case 1:
+ val = *iterCount;
+ break;
+ case 2:
+ val = CInt64_ShrU(*iterCount, cint64_one);
+ break;
+ case 4:
+ val = CInt64_ShrU(*iterCount, IRO_MakeLong(2));
+ break;
+ case 8:
+ val = CInt64_ShrU(*iterCount, IRO_MakeLong(3));
+ break;
+ case 16:
+ val = CInt64_ShrU(*iterCount, IRO_MakeLong(4));
+ break;
+ default:
+ val = CInt64_Div(*iterCount, strideVal);
+ }
+
+ if (CInt64_LessU(val, IRO_MakeLong(*unrollFactor)))
+ *unrollFactor = CInt64_GetULong(&val);
+
+ CInt64_SetLong(&val2, *unrollFactor);
+ switch (vectorStride) {
+ case 1:
+ val3 = cint64_zero;
+ break;
+ case 2:
+ val3 = CInt64_And(*iterCount, cint64_one);
+ break;
+ case 4:
+ val3 = CInt64_And(*iterCount, IRO_MakeLong(3));
+ break;
+ case 8:
+ val3 = CInt64_And(*iterCount, IRO_MakeLong(7));
+ break;
+ case 16:
+ val3 = CInt64_And(*iterCount, IRO_MakeLong(15));
+ break;
+ default:
+ val3 = CInt64_Mod(*iterCount, strideVal);
+ }
+
+ if (CInt64_LessEqualU(val, IRO_MakeLong(8))) {
+ *needUnrollBodyTest = vectorStride > 1;
+ *unrollFactor = CInt64_GetULong(&val);
+ *leftOver = CInt64_GetULong(&val3);
+ *needOrigLoop = *leftOver != 0;
+ *resetUnrolledFinalValue = !(*needOrigLoop && *needUnrollBodyTest);
+ } else {
+ loopvar1 = IRO_MakeLong(0x7FFFFFFF);
+ loopvar2 = IRO_MakeLong(0x7FFFFFFF);
+ do {
+ mod = CInt64_Mod(val, val2);
+ loopvar3 = CInt64_Add(CInt64_Mul(mod, strideVal), val3);
+ if (CInt64_Less(loopvar3, loopvar2)) {
+ loopvar2 = loopvar3;
+ loopvar1 = val2;
+ }
+ if (vectorStride > 1)
+ break;
+ val2 = CInt64_Add(val2, cint64_negone);
+ } while (CInt64_GreaterEqualU(CInt64_Mul(val2, val2), val));
+
+ *unrollFactor = CInt64_GetULong(&loopvar1);
+ *leftOver = CInt64_GetULong(&loopvar2);
+ *needOrigLoop = *leftOver != 0;
+ *needUnrollBodyTest = CInt64_Less(loopvar1, val) || vectorStride > 1;
+ *resetUnrolledFinalValue = !(*needOrigLoop && *needUnrollBodyTest);
+ }
+ }
+
+ IRO_Dump(
+ "---- IterCount = %d, VectorStride = %d, UnrollFactor = %d, LeftOver = %d,\n"
+ "\tNeedOrigLoop = %d, NeedUnrollBodyTest = %d, ResetUnrolledFinalValue = %d\n",
+ CInt64_GetULong(iterCount), vectorStride, *unrollFactor, *leftOver,
+ *needOrigLoop, *needUnrollBodyTest, *resetUnrolledFinalValue
+ );
}
-void BuildOrigIterationCount() {
+IROLinear *BuildOrigIterationCount(IROList *list, IROLoop *loop) {
+ IROLinear *upperBound;
+ IROLinear *nd29b;
+ IROLinear *lowerBound;
+ IROLinear *finalCount;
+ IROLinear *divisor;
+ Type *type;
+ IROLinear *nd25;
+ IROLinear *tmp;
+ Boolean isZeroBase;
+ Object *tempobj;
+ IROLinear *iterCount;
+ IROLinear *negone;
+ IROLinear *ass;
+ ENode *expr;
+ SInt32 powval;
+
+ isZeroBase = 0;
+ lowerBound = loop->nd14->u.diadic.right;
+ if (IRO_IsIntConstant(lowerBound) && CInt64_Equal(lowerBound->u.node->data.intval, cint64_zero))
+ isZeroBase = 1;
+
+ if (!isZeroBase)
+ lowerBound = IRO_DuplicateExpr(lowerBound, list);
+
+ if (loop->flags & LoopFlags_1) {
+ upperBound = IRO_DuplicateExpr(loop->nd18->u.diadic.right, list);
+ type = loop->nd18->u.diadic.right->rtype;
+ } else {
+ upperBound = IRO_DuplicateExpr(loop->nd18->u.diadic.left, list);
+ type = loop->nd18->u.diadic.left->rtype;
+ }
+
+ CError_ASSERT(2924, loop->induction);
+ CError_ASSERT(2929, loop->induction->addConst);
+
+ divisor = IRO_NewLinear(IROLinearOperand);
+ divisor->index = ++IRO_NumLinear;
+ divisor->rtype = type;
+ expr = IRO_NewENode(EINTCONST);
+ expr->rtype = type;
+ CInt64_SetLong(&expr->data.intval, loop->induction->addConst);
+ divisor->u.node = expr;
+
+ if (isZeroBase) {
+ iterCount = upperBound;
+ } else {
+ iterCount = IRO_NewLinear(IROLinearOp2Arg);
+ iterCount->index = ++IRO_NumLinear;
+ iterCount->nodetype = ESUB;
+ iterCount->u.diadic.left = upperBound;
+ iterCount->u.diadic.right = lowerBound;
+ iterCount->rtype = type;
+ IRO_AddToList(iterCount, list);
+ }
+
+ nd25 = IRO_DuplicateExpr(divisor, list);
+
+ nd29b = IRO_NewLinear(IROLinearOp2Arg);
+ nd29b->index = ++IRO_NumLinear;
+ nd29b->nodetype = EADD;
+ nd29b->u.diadic.left = iterCount;
+ nd29b->u.diadic.right = nd25;
+ nd29b->rtype = type;
+ IRO_AddToList(nd29b, list);
+
+ if (loop->nd18->type == IROLinearOp2Arg && loop->nd18->nodetype == ELESS) {
+ tmp = nd29b;
+
+ negone = IRO_NewLinear(IROLinearOperand);
+ negone->index = ++IRO_NumLinear;
+ negone->rtype = type;
+ expr = IRO_NewENode(EINTCONST);
+ expr->rtype = type;
+ CInt64_SetLong(&expr->data.intval, -1);
+ negone->u.node = expr;
+ IRO_AddToList(negone, list);
+
+ nd29b = IRO_NewLinear(IROLinearOp2Arg);
+ nd29b->index = ++IRO_NumLinear;
+ nd29b->nodetype = EADD;
+ nd29b->u.diadic.left = tmp;
+ nd29b->u.diadic.right = negone;
+ nd29b->rtype = type;
+ IRO_AddToList(nd29b, list);
+ }
+
+ if (CInt64_Equal(divisor->u.node->data.intval, cint64_one)) {
+ finalCount = nd29b;
+ } else {
+ if (divisor->rtype->size <= 4 && IS_TYPE_INT(divisor->rtype) && IRO_IsPow2(divisor, &powval)) {
+ finalCount = IRO_NewLinear(IROLinearOp2Arg);
+ finalCount->index = ++IRO_NumLinear;
+ finalCount->nodetype = ESHL;
+ finalCount->u.diadic.left = nd29b;
+ finalCount->u.diadic.right = divisor;
+ CInt64_SetLong(&divisor->u.node->data.intval, powval);
+ finalCount->rtype = type;
+ IRO_AddToList(divisor, list);
+ IRO_AddToList(finalCount, list);
+ } else {
+ finalCount = IRO_NewLinear(IROLinearOp2Arg);
+ finalCount->index = ++IRO_NumLinear;
+ finalCount->nodetype = EDIV;
+ finalCount->u.diadic.left = nd29b;
+ finalCount->u.diadic.right = divisor;
+ finalCount->rtype = type;
+ IRO_AddToList(divisor, list);
+ IRO_AddToList(finalCount, list);
+ }
+ }
+
+ tempobj = create_temp_object(type);
+ IRO_FindVar(tempobj, 1, 1);
+
+ ass = IRO_NewLinear(IROLinearOp2Arg);
+ ass->index = ++IRO_NumLinear;
+ ass->nodetype = EASS;
+ ass->u.diadic.left = IRO_TempReference(tempobj, list);
+ ass->u.diadic.left->flags |= IROLF_Assigned | IROLF_Ind;
+ ass->u.diadic.left->u.monadic->flags |= IROLF_Assigned | IROLF_Ind;
+ ass->u.diadic.right = finalCount;
+ ass->u.diadic.right->flags |= IROLF_Reffed;
+ ass->rtype = type;
+ IRO_AddToList(ass, list);
+
+ return ass->u.diadic.left;
}
-static void BuildOrigIterationCount_DoWhile() {
+static IROLinear *BuildOrigIterationCount_DoWhile(IROList *list, IROLoop *loop) {
+ IROLinear *finalCount;
+ IROLinear *count;
+ IROLinear *ass;
+ Type *type;
+ Object *tempobj;
+ ENode *expr;
+
+ type = loop->nd18->u.diadic.left->rtype;
+
+ count = IRO_NewLinear(IROLinearOperand);
+ count->index = ++IRO_NumLinear;
+ expr = IRO_NewENode(EINTCONST);
+ expr->rtype = type;
+ expr->data.intval = cint64_one;
+ count->u.node = expr;
+ count->rtype = type;
+ IRO_AddToList(count, list);
+ count->flags |= IROLF_Reffed;
+
+ finalCount = IRO_NewLinear(IROLinearOp2Arg);
+ finalCount->index = ++IRO_NumLinear;
+ finalCount->nodetype = EADD;
+ finalCount->rtype = type;
+ finalCount->u.diadic.left = IRO_DuplicateExpr(loop->nd18->u.diadic.left, list);
+ finalCount->u.diadic.left->flags |= IROLF_Reffed;
+ finalCount->u.diadic.left->flags &= ~IROLF_Assigned;
+ finalCount->u.diadic.left->u.monadic->flags &= ~IROLF_Assigned;
+ finalCount->u.diadic.right = count;
+ IRO_AddToList(finalCount, list);
+
+ tempobj = create_temp_object(type);
+ IRO_FindVar(tempobj, 1, 1);
+
+ ass = IRO_NewLinear(IROLinearOp2Arg);
+ ass->index = ++IRO_NumLinear;
+ ass->nodetype = EASS;
+ ass->u.diadic.left = IRO_TempReference(tempobj, list);
+ ass->u.diadic.left->flags |= IROLF_Assigned | IROLF_Ind;
+ ass->u.diadic.left->u.monadic->flags |= IROLF_Assigned | IROLF_Ind;
+ ass->u.diadic.right = finalCount;
+ ass->rtype = type;
+ IRO_AddToList(ass, list);
+
+ return ass->u.diadic.left;
}
-void BuildNewFinalvalue() {
+IROLinear *BuildNewFinalvalue(IROLinear *iterCount, UInt32 unrollFactor, IROList *list, IROLoop *loop) {
+ IROLinear *sub;
+ IROLinear *addvalue;
+ Type *type;
+ IROLinear *ass;
+ IROLinear *dupbound;
+ Object *tempobj;
+ ENode *expr;
+
+ type = iterCount->rtype;
+
+ addvalue = IRO_NewLinear(IROLinearOperand);
+ addvalue->index = ++IRO_NumLinear;
+ addvalue->rtype = type;
+ expr = IRO_NewENode(EINTCONST);
+ expr->rtype = type;
+ CInt64_SetLong(&expr->data.intval, loop->induction->addConst * unrollFactor);
+ addvalue->u.node = expr;
+ IRO_AddToList(addvalue, list);
+
+ if (loop->flags & LoopFlags_1)
+ dupbound = IRO_DuplicateExpr(loop->nd18->u.diadic.right, list);
+ else
+ dupbound = IRO_DuplicateExpr(loop->nd18->u.diadic.left, list);
+
+ sub = IRO_NewLinear(IROLinearOp2Arg);
+ sub->index = ++IRO_NumLinear;
+ sub->nodetype = ESUB;
+ sub->u.diadic.left = dupbound;
+ sub->u.diadic.right = addvalue;
+ sub->rtype = type;
+ IRO_AddToList(sub, list);
+
+ tempobj = create_temp_object(type);
+ IRO_FindVar(tempobj, 1, 1);
+
+ ass = IRO_NewLinear(IROLinearOp2Arg);
+ ass->index = ++IRO_NumLinear;
+ ass->nodetype = EASS;
+ ass->u.diadic.left = IRO_TempReference(tempobj, list);
+ ass->u.diadic.left->flags |= IROLF_Assigned | IROLF_Ind;
+ ass->u.diadic.left->u.monadic->flags |= IROLF_Assigned | IROLF_Ind;
+ ass->u.diadic.right = sub;
+ ass->u.diadic.right->flags |= IROLF_Reffed;
+ ass->rtype = type;
+ IRO_AddToList(ass, list);
+
+ return ass->u.diadic.left;
}
-static void BuildPreAlignTemp() {
+static IROLinear *BuildPreAlignTemp(IROLoopInd *ind, UInt32 unrollFactor, IROList *list) {
+ Type *type;
+ IROLinear *indnd;
+ IROLinear *factornd;
+ IROLinear *div;
+ IROLinear *constnd;
+ IROLinear *add;
+ IROLinear *mul;
+ IROLinear *ass;
+ Object *tempobj;
+ ENode *expr;
+
+ indnd = ind->nd;
+ type = indnd->rtype;
+
+ factornd = IRO_NewLinear(IROLinearOperand);
+ factornd->index = ++IRO_NumLinear;
+ factornd->rtype = type;
+ expr = IRO_NewENode(EINTCONST);
+ expr->rtype = type;
+ CInt64_SetLong(&expr->data.intval, unrollFactor);
+ factornd->u.node = expr;
+ IRO_AddToList(factornd, list);
+
+ if (indnd->type == IROLinearOp1Arg)
+ IRO_DuplicateExpr(indnd->u.monadic, list);
+ else
+ IRO_DuplicateExpr(indnd->u.diadic.left, list);
+
+ list->tail->flags &= ~IROLF_Assigned;
+ list->tail->u.monadic->flags &= ~IROLF_Assigned;
+
+ div = IRO_NewLinear(IROLinearOp2Arg);
+ div->index = ++IRO_NumLinear;
+ div->nodetype = EDIV;
+ div->u.diadic.left = list->tail;
+ div->u.diadic.right = factornd;
+ div->rtype = type;
+ IRO_AddToList(div, list);
+ div->flags |= IROLF_Reffed;
+
+ constnd = IRO_NewLinear(IROLinearOperand);
+ constnd->index = ++IRO_NumLinear;
+ expr = IRO_NewENode(EINTCONST);
+ expr->rtype = type;
+ expr->data.intval = cint64_one;
+ constnd->u.node = expr;
+ constnd->rtype = type;
+ IRO_AddToList(constnd, list);
+ constnd->flags |= IROLF_Reffed;
+
+ add = IRO_NewLinear(IROLinearOp2Arg);
+ add->index = ++IRO_NumLinear;
+ add->nodetype = EADD;
+ add->u.diadic.left = div;
+ add->u.diadic.right = constnd;
+ add->rtype = type;
+ IRO_AddToList(add, list);
+ add->flags |= IROLF_Reffed;
+
+ IRO_DuplicateExpr(factornd, list);
+
+ mul = IRO_NewLinear(IROLinearOp2Arg);
+ mul->index = ++IRO_NumLinear;
+ mul->nodetype = EMUL;
+ mul->u.diadic.left = add;
+ mul->u.diadic.right = list->tail;
+ mul->rtype = type;
+ IRO_AddToList(mul, list);
+ mul->flags |= IROLF_Reffed;
+
+ tempobj = create_temp_object(type);
+ IRO_FindVar(tempobj, 1, 1);
+
+ ass = IRO_NewLinear(IROLinearOp2Arg);
+ ass->index = ++IRO_NumLinear;
+ ass->nodetype = EASS;
+ ass->u.diadic.left = IRO_TempReference(tempobj, list);
+ ass->u.diadic.left->flags |= IROLF_Assigned | IROLF_Ind;
+ ass->u.diadic.left->u.monadic->flags |= IROLF_Assigned | IROLF_Ind;
+ ass->u.diadic.right = mul;
+ ass->u.diadic.right->flags |= IROLF_Reffed;
+ ass->rtype = type;
+ IRO_AddToList(ass, list);
+
+ return ass->u.diadic.left;
}
-static void BuildNewFinalvalue_DoWhile() {
+static IROLinear *BuildNewFinalvalue_DoWhile(IROLinear *iterCount, UInt32 unrollFactor, IROList *list, IROLoop *loop) {
+ IROLinear *addvalue;
+ IROLinear *add;
+ IROLinear *mul;
+ IROLinear *ass;
+ Type *type;
+ Object *tempobj;
+ ENode *expr;
+
+ type = iterCount->rtype;
+
+ addvalue = IRO_NewLinear(IROLinearOperand);
+ addvalue->index = ++IRO_NumLinear;
+ addvalue->rtype = type;
+ expr = IRO_NewENode(EINTCONST);
+ expr->rtype = type;
+ CInt64_SetLong(&expr->data.intval, loop->induction->addConst);
+ addvalue->u.node = expr;
+ IRO_AddToList(addvalue, list);
+ addvalue->flags |= IROLF_Reffed;
+
+ mul = IRO_NewLinear(IROLinearOp2Arg);
+ mul->index = ++IRO_NumLinear;
+ mul->nodetype = EMUL;
+ mul->u.diadic.left = IRO_DuplicateExpr(iterCount, list);
+ mul->u.diadic.right = addvalue;
+ mul->rtype = type;
+ IRO_AddToList(mul, list);
+ mul->flags |= IROLF_Reffed;
+ mul->u.diadic.left->flags &= ~IROLF_Assigned;
+ mul->u.diadic.left->u.diadic.left->flags &= ~IROLF_Assigned;
+
+ if (loop->induction->nd->type == IROLinearOp1Arg)
+ IRO_DuplicateExpr(loop->induction->nd->u.monadic, list);
+ else
+ IRO_DuplicateExpr(loop->induction->nd->u.diadic.left, list);
+ list->tail->flags &= ~IROLF_Assigned;
+ list->tail->u.diadic.left->flags &= ~IROLF_Assigned;
+
+ add = IRO_NewLinear(IROLinearOp2Arg);
+ add->index = ++IRO_NumLinear;
+ add->nodetype = EADD;
+ add->u.diadic.left = mul;
+ add->u.diadic.right = list->tail;
+ add->rtype = type;
+ IRO_AddToList(add, list);
+ add->flags |= IROLF_Reffed;
+
+ tempobj = create_temp_object(type);
+ IRO_FindVar(tempobj, 1, 1);
+
+ ass = IRO_NewLinear(IROLinearOp2Arg);
+ ass->index = ++IRO_NumLinear;
+ ass->nodetype = EASS;
+ ass->u.diadic.left = IRO_TempReference(tempobj, list);
+ ass->u.diadic.left->flags |= IROLF_Assigned | IROLF_Ind;
+ ass->u.diadic.left->u.monadic->flags |= IROLF_Assigned | IROLF_Ind;
+ ass->u.diadic.right = add;
+ ass->u.diadic.right->flags |= IROLF_Reffed;
+ ass->rtype = type;
+ IRO_AddToList(ass, list);
+
+ return ass->u.diadic.left;
}
-static void BuildUnrolledFinalvalue_DoWhile() {
+static IROLinear *BuildUnrolledFinalvalue_DoWhile(IROLinear *iterCount, UInt32 unrollFactor, IROList *list, IROLoop *loop) {
+ IROLinear *addvalue_mult;
+ IROLinear *addvalue;
+ IROLinear *mul;
+ IROLinear *sub;
+ IROLinear *add;
+ IROLinear *ass;
+ Type *type;
+ Object *tempobj;
+ ENode *expr;
+
+ type = iterCount->rtype;
+
+ addvalue_mult = IRO_NewLinear(IROLinearOperand);
+ addvalue_mult->index = ++IRO_NumLinear;
+ addvalue_mult->rtype = type;
+ expr = IRO_NewENode(EINTCONST);
+ expr->rtype = type;
+ CInt64_SetLong(&expr->data.intval, loop->induction->addConst * unrollFactor);
+ addvalue_mult->u.node = expr;
+ IRO_AddToList(addvalue_mult, list);
+ addvalue_mult->flags |= IROLF_Reffed;
+
+ addvalue = IRO_NewLinear(IROLinearOperand);
+ addvalue->index = ++IRO_NumLinear;
+ addvalue->rtype = type;
+ expr = IRO_NewENode(EINTCONST);
+ expr->rtype = type;
+ CInt64_SetLong(&expr->data.intval, loop->induction->addConst);
+ addvalue->u.node = expr;
+ IRO_AddToList(addvalue, list);
+ addvalue->flags |= IROLF_Reffed;
+
+ mul = IRO_NewLinear(IROLinearOp2Arg);
+ mul->index = ++IRO_NumLinear;
+ mul->nodetype = EMUL;
+ mul->u.diadic.left = IRO_DuplicateExpr(iterCount, list);
+ mul->u.diadic.right = addvalue;
+ mul->rtype = type;
+ IRO_AddToList(mul, list);
+ mul->flags |= IROLF_Reffed;
+ mul->u.diadic.left->flags &= ~IROLF_Assigned;
+ mul->u.diadic.left->u.diadic.left->flags &= ~IROLF_Assigned;
+
+ sub = IRO_NewLinear(IROLinearOp2Arg);
+ sub->index = ++IRO_NumLinear;
+ sub->nodetype = ESUB;
+ sub->u.diadic.left = mul;
+ sub->u.diadic.right = addvalue_mult;
+ sub->rtype = type;
+ IRO_AddToList(sub, list);
+ sub->flags |= IROLF_Reffed;
+
+ if (loop->induction->nd->type == IROLinearOp1Arg)
+ IRO_DuplicateExpr(loop->induction->nd->u.monadic, list);
+ else
+ IRO_DuplicateExpr(loop->induction->nd->u.diadic.left, list);
+ list->tail->flags &= ~IROLF_Assigned;
+ list->tail->u.diadic.left->flags &= ~IROLF_Assigned;
+
+ add = IRO_NewLinear(IROLinearOp2Arg);
+ add->index = ++IRO_NumLinear;
+ add->nodetype = EADD;
+ add->u.diadic.left = sub;
+ add->u.diadic.right = list->tail;
+ add->rtype = type;
+ IRO_AddToList(add, list);
+ add->flags |= IROLF_Reffed;
+
+ tempobj = create_temp_object(type);
+ IRO_FindVar(tempobj, 1, 1);
+
+ ass = IRO_NewLinear(IROLinearOp2Arg);
+ ass->index = ++IRO_NumLinear;
+ ass->nodetype = EASS;
+ ass->u.diadic.left = IRO_TempReference(tempobj, list);
+ ass->u.diadic.left->flags |= IROLF_Assigned | IROLF_Ind;
+ ass->u.diadic.left->u.monadic->flags |= IROLF_Assigned | IROLF_Ind;
+ ass->u.diadic.right = add;
+ ass->u.diadic.right->flags |= IROLF_Reffed;
+ ass->rtype = type;
+ IRO_AddToList(ass, list);
+
+ return ass->u.diadic.left;
}
-void BuildUnrolledBodyEntryTest() {
+void BuildUnrolledBodyEntryTest(IROList *list, IROLinear *iterCount, UInt32 unrollFactor, CLabel *label) {
+ Type *type;
+ IROLinear *ifnot;
+ IROLinear *comp;
+ IROLinear *var;
+ IROLinear *value;
+ ENode *expr;
+
+ type = iterCount->rtype;
+
+ value = IRO_NewLinear(IROLinearOperand);
+ value->index = ++IRO_NumLinear;
+ value->rtype = type;
+ expr = IRO_NewENode(EINTCONST);
+ expr->rtype = type;
+ CInt64_SetLong(&expr->data.intval, unrollFactor);
+ value->u.node = expr;
+ IRO_AddToList(value, list);
+
+ var = IRO_DuplicateExpr(iterCount, list);
+
+ comp = IRO_NewLinear(IROLinearOp2Arg);
+ comp->index = ++IRO_NumLinear;
+ comp->nodetype = EGREATER;
+ comp->u.diadic.left = var;
+ comp->u.diadic.right = value;
+ comp->u.diadic.right->flags |= IROLF_Reffed;
+ comp->rtype = type;
+ IRO_AddToList(comp, list);
+
+ ifnot = IRO_NewLinear(IROLinearOp1Arg);
+ ifnot->index = ++IRO_NumLinear;
+ ifnot->type = IROLinearIfNot;
+ ifnot->u.label.x4 = comp;
+ ifnot->u.label.x4->flags |= IROLF_Reffed;
+ ifnot->rtype = type;
+ ifnot->u.label.label = label;
+ IRO_AddToList(ifnot, list);
}
-void ChangeInductionReference() {
+void ChangeInductionReference(IROLinear *first, IROLinear *last, CInt64 val, IROLoop *loop) {
+ IROLinear *nd;
+ IROLinear *value;
+ IROLinear *add;
+ UInt32 isUnsigned;
+ IROLinear *father;
+ Boolean flag;
+ IROLinear *father2;
+ IROLinear *father3;
+ Type *tmp;
+ UInt32 flag2;
+ Object *varobj;
+ IROLinear *next;
+ ENode *expr;
+ Type *type;
+
+ CInt64 val2;
+ CInt64 val1;
+ IROList list;
+
+ type = loop->induction->nd->rtype;
+ isUnsigned = IRO_IsUnsignedType(type);
+
+ for (nd = first; nd; nd = next) {
+ next = nd->next;
+
+ varobj = IRO_IsVariable(nd);
+ if (varobj && loop->induction->var->object == varobj) {
+ value = IRO_NewLinear(IROLinearOperand);
+ value->index = ++IRO_NumLinear;
+ value->rtype = type;
+ expr = IRO_NewENode(EINTCONST);
+ expr->rtype = type;
+ expr->data.intval = val;
+ value->u.node = expr;
+
+ add = IRO_NewLinear(IROLinearOp2Arg);
+ add->index = ++IRO_NumLinear;
+ add->nodetype = EADD;
+ add->rtype = type;
+
+ father = IRO_LocateFather(nd);
+ flag = 1;
+ if (father && IS_LINEAR_MONADIC(father, ETYPCON)) {
+ tmp = father->rtype;
+ father = IRO_LocateFather(father);
+ if (tmp->type != nd->rtype->type || tmp->size < nd->rtype->size)
+ flag = 0;
+ }
+
+ flag2 = 0;
+ if (
+ flag &&
+ father &&
+ IS_LINEAR_DIADIC_2(father, ESHL, EMUL) &&
+ IRO_IsIntConstant(father->u.diadic.right) &&
+ (father2 = IRO_LocateFather(father)) &&
+ IS_LINEAR_DIADIC(father2, EADD) &&
+ father2->u.diadic.right == father &&
+ (father3 = IRO_LocateFather(father2))
+ )
+ {
+ IRO_InitList(&list);
+ val2 = father->u.diadic.right->u.node->data.intval;
+ if (father->nodetype == ESHL)
+ val2 = CInt64_Shl(cint64_one, val2);
+
+ val1 = value->u.node->data.intval;
+ if (isUnsigned)
+ val1 = CInt64_MulU(val2, val1);
+ else
+ val1 = CInt64_Mul(val2, val1);
+ value->u.node->data.intval = val1;
+
+ IRO_AddToList(value, &list);
+ IRO_AddToList(add, &list);
+ add->u.diadic.right = value;
+ IRO_Paste(list.head, list.tail, father3);
+ IRO_LocateFather_Cut_And_Paste_Without_Nopping(father2, add);
+ add->u.diadic.left = father2;
+ add->rtype = father2->rtype;
+ flag2 = 1;
+ }
+
+ if (!flag2) {
+ add->u.diadic.right = value;
+ add->u.diadic.right->flags |= IROLF_Reffed;
+ value->next = add;
+
+ add->u.diadic.left = nd;
+ IRO_LocateFather_Cut_And_Paste_Without_Nopping(nd, add);
+ add->flags |= IROLF_Reffed;
+
+ nd->next = value;
+ add->next = next;
+ }
+ }
+
+ if (nd == last)
+ break;
+ }
}
-void UpdateInductionIncrement() {
+IROLinear *UpdateInductionIncrement(IROLoop *loop, SInt32 value, IROLinear *before) {
+ IROLinear *ind_nd;
+ IROLinear *addvalue;
+ IROLinear *ass;
+ Type *type;
+ ENode *expr;
+ IROList list;
+
+ IRO_InitList(&list);
+ ind_nd = loop->induction->nd;
+ type = ind_nd->rtype;
+
+ addvalue = IRO_NewLinear(IROLinearOperand);
+ addvalue->index = ++IRO_NumLinear;
+ addvalue->rtype = type;
+ expr = IRO_NewENode(EINTCONST);
+ expr->rtype = type;
+ CInt64_SetLong(&expr->data.intval, value * loop->induction->addConst);
+ addvalue->u.node = expr;
+ IRO_AddToList(addvalue, &list);
+
+ if (IS_LINEAR_MONADIC_2(ind_nd, EPREINC, EPOSTINC)) {
+ ind_nd = IRO_DuplicateExpr(ind_nd->u.monadic, &list);
+
+ ass = IRO_NewLinear(IROLinearOp2Arg);
+ ass->index = ++IRO_NumLinear;
+ ass->nodetype = EADDASS;
+ ass->u.diadic.left = ind_nd;
+ ass->u.diadic.right = addvalue;
+ ass->rtype = type;
+ IRO_AddToList(ass, &list);
+ } else if (IS_LINEAR_MONADIC_2(ind_nd, EPREDEC, EPOSTDEC)) {
+ ind_nd = IRO_DuplicateExpr(ind_nd->u.monadic, &list);
+
+ ass = IRO_NewLinear(IROLinearOp2Arg);
+ ass->index = ++IRO_NumLinear;
+ ass->nodetype = ESUBASS;
+ ass->u.diadic.left = ind_nd;
+ ass->u.diadic.right = addvalue;
+ ass->rtype = type;
+ IRO_AddToList(ass, &list);
+ } else if (IS_LINEAR_DIADIC(ind_nd, EADDASS)) {
+ ind_nd = IRO_DuplicateExpr(ind_nd->u.monadic, &list);
+
+ ass = IRO_NewLinear(IROLinearOp2Arg);
+ ass->index = ++IRO_NumLinear;
+ ass->nodetype = EADDASS;
+ ass->u.diadic.left = ind_nd;
+ ass->u.diadic.right = addvalue;
+ ass->rtype = type;
+ IRO_AddToList(ass, &list);
+ }
+
+ IRO_Paste(list.head, list.tail, before);
+ return list.tail;
}
-void GenInitialAssignment() {
+void GenInitialAssignment(IROLoop *loop, Object *var, IROList *list) {
+ Type *type;
+ IROLinear *nd;
+
+ CError_ASSERT(3924, loop->nd14 && loop->nd14->type == IROLinearOp2Arg);
+
+ type = loop->induction->nd->rtype;
+
+ nd = IRO_NewLinear(IROLinearOp2Arg);
+ nd->index = ++IRO_NumLinear;
+ nd->nodetype = EASS;
+ nd->u.diadic.left = IRO_TempReference(var, list);
+ nd->u.diadic.right = IRO_DuplicateExpr(loop->nd14->u.diadic.right, list);
+ nd->rtype = type;
+ IRO_AddToList(nd, list);
}
-void GenNewInduction() {
+void GenNewInduction(void) {
+ CError_FATAL(3941);
}
diff --git a/compiler_and_linker/unsorted/IroUtil.c b/compiler_and_linker/unsorted/IroUtil.c
index 67edd4b..53e6733 100644
--- a/compiler_and_linker/unsorted/IroUtil.c
+++ b/compiler_and_linker/unsorted/IroUtil.c
@@ -956,10 +956,40 @@ void IRO_ReplaceReferenceWithNode(IROLinear *a, IROLinear *b) {
}
}
-void IRO_GetTemp(IROExpr *expr) {
+VarRecord *IRO_GetTemp(IROExpr *expr) {
+ expr->x8 = create_temp_object(expr->linear->rtype);
+ return IRO_FindVar(expr->x8, 1, 1);
}
IROLinear *IRO_AssignToTemp(IROExpr *expr) {
+ IROLinear *objref;
+ IROLinear *ind;
+ IROLinear *ass;
+
+ objref = IRO_NewLinear(IROLinearOperand);
+ objref->u.node = create_objectrefnode(expr->x8);
+ objref->rtype = objref->u.node->data.objref->type;
+ objref->index = ++IRO_NumLinear;
+ objref->flags |= IROLF_Reffed | IROLF_Assigned | IROLF_Ind;
+
+ ind = IRO_NewLinear(IROLinearOp1Arg);
+ ind->nodetype = EINDIRECT;
+ ind->rtype = expr->linear->rtype;
+ ind->u.monadic = objref;
+ ind->index = ++IRO_NumLinear;
+ ind->flags |= IROLF_Reffed | IROLF_Assigned;
+
+ ass = IRO_NewLinear(IROLinearOp2Arg);
+ ass->nodetype = EASS;
+ ass->u.diadic.left = ind;
+ ass->u.diadic.right = expr->linear;
+ ass->rtype = expr->linear->rtype;
+ ass->index = ++IRO_NumLinear;
+
+ objref->next = ind;
+ ind->next = ass;
+ IRO_PasteAfter(objref, ass, expr->linear);
+ return ass;
}
IROLinear *IRO_FindStart(IROLinear *linear) {
@@ -993,7 +1023,7 @@ void IRO_RemoveCommaNodeFromIR(void) {
if (!linear)
break;
if (linear->nodetype == ECOMMA) {
- linear->u.diadic.left->flags &= ~IROLF_Reffed;
+ linear->u.diadic.left->flags = linear->u.diadic.left->flags & ~IROLF_Reffed;
IRO_LocateFather_Cut_And_Paste_Without_Nopping(linear, linear->u.diadic.right);
linear->type = IROLinearNop;
}
@@ -1200,7 +1230,7 @@ IROLinear *IRO_NewIntConst(CInt64 val, Type *type) {
return linear;
}
-IROLinear *IRO_NewFloatConst(Float val, Type *type) {
+IROLinear *IRO_NewFloatConst(const Float val, Type *type) {
ENode *node;
IROLinear *linear;
@@ -1230,4 +1260,3 @@ void IRO_CheckForUserBreak(void) {
IRO_LastUserBreakTick = COS_GetTicks();
}
}
-
diff --git a/compiler_and_linker/unsorted/IroVars.c b/compiler_and_linker/unsorted/IroVars.c
index a40656a..15e7e65 100644
--- a/compiler_and_linker/unsorted/IroVars.c
+++ b/compiler_and_linker/unsorted/IroVars.c
@@ -1113,7 +1113,7 @@ void IRO_ScalarizeClassDataMembers(void) {
}
if (nd->type == IROLinearAsm) {
IAEffects effects;
- int i;
+ SInt32 i;
CodeGen_GetAsmEffects(nd->u.asm_stmt, &effects);
for (i = 0; i < effects.numoperands; i++) {
if ((var = IRO_FindVar(effects.operands[i].object, 0, 1)))
diff --git a/compiler_and_linker/unsorted/LoopOptimization.c b/compiler_and_linker/unsorted/LoopOptimization.c
index 1c0b905..c2a360f 100644
--- a/compiler_and_linker/unsorted/LoopOptimization.c
+++ b/compiler_and_linker/unsorted/LoopOptimization.c
@@ -843,19 +843,19 @@ static void rewriteunknownloopwithBDNZ(Loop *loop) {
if (loop->unknownCondition == ELESS) {
branchOpcode = PC_BF;
if (loop->lowerType == LOOP_BOUND_CONSTANT) {
- branchCondition = 1;
+ branchCondition = 1; // GT
value1 = loop->lower;
reg1 = addiInstr->args[2].data.reg.reg;
value2 = absStep - 1 - loop->lower;
mode = 0;
} else if (loop->upperType == LOOP_BOUND_CONSTANT) {
- branchCondition = 0;
+ branchCondition = 0; // LT
value1 = loop->upper;
reg1 = addiInstr->args[1].data.reg.reg;
value2 = absStep - 1 + loop->upper;
mode = 1;
} else {
- branchCondition = 0;
+ branchCondition = 0; // LT
reg1 = addiInstr->args[1].data.reg.reg;
reg2 = addiInstr->args[2].data.reg.reg;
value2 = absStep - 1;
@@ -864,19 +864,19 @@ static void rewriteunknownloopwithBDNZ(Loop *loop) {
} else if (loop->unknownCondition == ELESSEQU) {
branchOpcode = PC_BT;
if (loop->lowerType == LOOP_BOUND_CONSTANT) {
- branchCondition = 0;
+ branchCondition = 0; // LT
value1 = loop->lower;
reg1 = addiInstr->args[2].data.reg.reg;
value2 = absStep - loop->lower;
mode = 0;
} else if (loop->upperType == LOOP_BOUND_CONSTANT) {
- branchCondition = 1;
+ branchCondition = 1; // GT
value1 = loop->upper;
reg1 = addiInstr->args[1].data.reg.reg;
value2 = absStep + loop->upper;
mode = 1;
} else {
- branchCondition = 1;
+ branchCondition = 1; // GT
value1 = 0;
reg1 = addiInstr->args[1].data.reg.reg;
reg2 = addiInstr->args[2].data.reg.reg;
@@ -886,19 +886,19 @@ static void rewriteunknownloopwithBDNZ(Loop *loop) {
} else if (loop->unknownCondition == EGREATER) {
branchOpcode = PC_BF;
if (loop->lowerType == LOOP_BOUND_CONSTANT) {
- branchCondition = 0;
+ branchCondition = 0; // LT
value1 = loop->lower;
reg1 = addiInstr->args[2].data.reg.reg;
value2 = absStep - 1 + loop->lower;
mode = 1;
} else if (loop->upperType == LOOP_BOUND_CONSTANT) {
- branchCondition = 1;
+ branchCondition = 1; // GT
value1 = loop->upper;
reg1 = addiInstr->args[1].data.reg.reg;
value2 = absStep - 1 - loop->upper;
mode = 0;
} else {
- branchCondition = 1;
+ branchCondition = 1; // GT
value1 = 0;
reg1 = addiInstr->args[1].data.reg.reg;
reg2 = addiInstr->args[2].data.reg.reg;
@@ -908,19 +908,19 @@ static void rewriteunknownloopwithBDNZ(Loop *loop) {
} else if (loop->unknownCondition == EGREATEREQU) {
branchOpcode = PC_BT;
if (loop->lowerType == LOOP_BOUND_CONSTANT) {
- branchCondition = 1;
+ branchCondition = 1; // GT
value1 = loop->lower;
reg1 = addiInstr->args[2].data.reg.reg;
value2 = absStep + loop->lower;
mode = 1;
} else if (loop->upperType == LOOP_BOUND_CONSTANT) {
- branchCondition = 0;
+ branchCondition = 0; // LT
value1 = loop->upper;
reg1 = addiInstr->args[1].data.reg.reg;
value2 = absStep - loop->upper;
mode = 0;
} else {
- branchCondition = 0;
+ branchCondition = 0; // LT
reg1 = addiInstr->args[1].data.reg.reg;
reg2 = addiInstr->args[2].data.reg.reg;
value2 = absStep;
@@ -928,7 +928,7 @@ static void rewriteunknownloopwithBDNZ(Loop *loop) {
}
} else if (loop->unknownCondition == ENOTEQU) {
branchOpcode = PC_BT;
- branchCondition = 2;
+ branchCondition = 2; // EQ
if (loop->step > 0) {
if (loop->lowerType == LOOP_BOUND_CONSTANT) {
value1 = loop->lower;
diff --git a/compiler_and_linker/unsorted/RegisterInfo.c b/compiler_and_linker/unsorted/RegisterInfo.c
index a5e9966..91d775f 100644
--- a/compiler_and_linker/unsorted/RegisterInfo.c
+++ b/compiler_and_linker/unsorted/RegisterInfo.c
@@ -75,7 +75,7 @@ void retain_GPR_pair(Object *obj, short reg, short regHi) {
}
int is_register_object(Object *obj) {
- return obj->sclass == OBJECT_SCLASS_101;
+ return obj->sclass == TK_REGISTER;
}
int GetABIFirstNonVolatile(RegClass rclass) {
@@ -118,10 +118,9 @@ void setup_diagnostic_reg_strings(void) {
}
void init_target_registers(void) {
- RegClass rclass;
int reg;
int end;
- int tmp;
+ RegClass rclass;
static int last_nonvolatile_reg[] = {3, 5, 31, 31, 31};
static int nonvol_reserve[] = {0, 0, 0, 4, 3};
@@ -153,8 +152,7 @@ void init_target_registers(void) {
end = first_nonvolatile_reg(rclass);
for (reg = last_nonvolatile_reg[rclass]; reg >= end; reg--) {
if (reg_state[rclass][reg] == RegState0) {
- tmp = n_nonvolatile_registers[rclass]++;
- nonvolatile_registers[rclass][tmp] = reg;
+ nonvolatile_registers[rclass][n_nonvolatile_registers[rclass]++] = reg;
}
}
}
@@ -167,8 +165,7 @@ void init_target_registers(void) {
for (reg = 0; reg < n_real_registers[rclass]; reg++) {
if (reg < GetABIFirstNonVolatile(rclass) || reg > last_nonvolatile_reg[rclass]) {
if (reg_state[rclass][reg] == RegState0) {
- tmp = n_scratch_registers[rclass]++;
- scratch_registers[rclass][tmp] = reg;
+ scratch_registers[rclass][n_scratch_registers[rclass]++] = reg;
}
}
}
@@ -250,9 +247,6 @@ void open_fe_temp_registers(void) {
first_fe_temporary_register[RegClass_FPR] = last_temporary_register[RegClass_FPR] = r;
r = used_virtual_registers[RegClass_VR];
first_fe_temporary_register[RegClass_VR] = last_temporary_register[RegClass_VR] = r;
- //first_fe_temporary_register[RegClass_GPR] = last_temporary_register[RegClass_GPR] = used_virtual_registers[RegClass_GPR];
- //first_fe_temporary_register[RegClass_FPR] = last_temporary_register[RegClass_FPR] = used_virtual_registers[RegClass_FPR];
- //first_fe_temporary_register[RegClass_VR] = last_temporary_register[RegClass_VR] = used_virtual_registers[RegClass_VR];
}
void set_last_exception_registers(void) {
@@ -371,14 +365,17 @@ void init_endian(void) {
void update_asm_nonvolatile_registers(void) {
RegClass rclass;
- int r31;
+ int i;
+ int reg;
for (rclass = 0; rclass < RegClassMax; rclass++) {
- for (r31 = n_nonvolatile_registers[rclass] - 1; r31 >= 0; r31--) {
- if (reg_state[rclass][nonvolatile_registers[rclass][r31]] == RegState1)
+ reg = n_nonvolatile_registers[rclass];
+ for (i = n_nonvolatile_registers[rclass] - 1; i >= 0; i--) {
+ if (reg_state[rclass][nonvolatile_registers[rclass][i]] == RegState1)
break;
+ reg--;
}
- if (r31 > used_nonvolatile_registers[rclass])
- used_nonvolatile_registers[rclass] = r31;
+ if (reg > used_nonvolatile_registers[rclass])
+ used_nonvolatile_registers[rclass] = reg;
}
}
diff --git a/compiler_and_linker/unsorted/StackFrame.c b/compiler_and_linker/unsorted/StackFrame.c
index a78552d..91b15da 100644
--- a/compiler_and_linker/unsorted/StackFrame.c
+++ b/compiler_and_linker/unsorted/StackFrame.c
@@ -71,8 +71,8 @@ static void restore_nonvolatile_GPRs(int reg, SInt32 offset);
static void do_allocate_dynamic_stack_space(Boolean isConstantSize, int reg1, int reg2, SInt32 size);
void init_stack_globals(Object *funcobj) {
- char rclass;
- UInt8 oclass;
+ RegClass rclass;
+ ObjClass oclass;
requires_frame = 0;
makes_call = 0;
@@ -109,7 +109,7 @@ void init_stack_globals(Object *funcobj) {
LR_save_offset = -1;
for (rclass = 0; rclass < RegClassMax; rclass++)
- non_volatile_save_offset[(char) rclass] = -1;
+ non_volatile_save_offset[rclass] = -1;
dummyprofiler = NULL;
dummyvaparam = NULL;
diff --git a/compiler_and_linker/unsorted/TOC.c b/compiler_and_linker/unsorted/TOC.c
index 49ae3e1..3fde61b 100644
--- a/compiler_and_linker/unsorted/TOC.c
+++ b/compiler_and_linker/unsorted/TOC.c
@@ -10,8 +10,12 @@
#include "compiler/CMangler.h"
#include "compiler/CParser.h"
#include "compiler/CodeGen.h"
+#include "compiler/CompilerTools.h"
#include "compiler/Exceptions.h"
+#include "compiler/InlineAsm.h"
+#include "compiler/InlineAsmPPC.h"
#include "compiler/InstrSelection.h"
+#include "compiler/Intrinsics.h"
#include "compiler/ObjGenMachO.h"
#include "compiler/Operands.h"
#include "compiler/PCode.h"
@@ -19,7 +23,6 @@
#include "compiler/PPCError.h"
#include "compiler/RegisterInfo.h"
#include "compiler/StackFrame.h"
-#include "compiler/CompilerTools.h"
#include "compiler/enode.h"
#include "compiler/objects.h"
#include "compiler/types.h"
@@ -27,10 +30,10 @@
ObjectList *toclist;
ObjectList *exceptionlist;
void *descriptorlist;
-void *floatconstpool;
-void *doubleconstpool;
+PoolEntry *floatconstpool;
+PoolEntry *doubleconstpool;
ObjectList *floatconstlist;
-void *vectorconstpool;
+PoolEntry *vectorconstpool;
ObjectList *vectorconstlist;
Object toc0;
Boolean no_descriptors;
@@ -126,7 +129,7 @@ void createNonLazyPointer(Object *obj) {
toc->toc = NULL;
toc->section = SECT_NONLAZY_PTRS;
toc->u.toc.info = CodeGen_GetNewVarInfo();
- toc->sclass = OBJECT_SCLASS_102;
+ toc->sclass = TK_STATIC;
toc->qual = Q_CONST;
toc->datatype = DNONLAZYPTR;
toc->flags |= OBJECT_FLAGS_2;
@@ -193,7 +196,7 @@ Object *createfloatconstant(Type *type, Float *data) {
obj->toc = NULL;
obj->u.data.info = NULL;
obj->u.data.linkname = obj->name;
- obj->sclass = OBJECT_SCLASS_102;
+ obj->sclass = TK_STATIC;
obj->qual = Q_CONST | Q_10000;
obj->datatype = DDATA;
if (type->size == 8)
@@ -238,7 +241,7 @@ Object *createvectorconstant(Type *type, MWVector128 *data) {
obj->toc = NULL;
obj->u.data.info = NULL;
obj->u.data.linkname = obj->name;
- obj->sclass = OBJECT_SCLASS_102;
+ obj->sclass = TK_STATIC;
obj->qual = Q_CONST | Q_10000;
obj->datatype = DDATA;
if (type->size == 16)
@@ -261,16 +264,153 @@ Object *createvectorconstant(Type *type, MWVector128 *data) {
return obj;
}
-void DeclarePooledConstants() {
- // TODO CInit
+void DeclarePooledConstants(void) {
+ PoolEntry *entry;
+ char *buffer;
+ SInt32 fsize;
+ SInt32 dsize;
+ SInt32 vsize;
+
+ fsize = 0;
+ for (entry = floatconstpool; entry; entry = entry->next)
+ fsize += 4;
+
+ if (fsize) {
+ floatconstpool->object->type = CDecl_NewArrayType(TYPE(&stfloat), fsize);
+ buffer = galloc(fsize);
+ for (entry = floatconstpool; entry; entry = entry->next)
+ memcpy(buffer + entry->offset, entry->buffer, 4);
+ CInit_DeclareReadOnlyData(floatconstpool->object, buffer, NULL, fsize);
+ }
+
+ dsize = 0;
+ for (entry = doubleconstpool; entry; entry = entry->next)
+ dsize += 8;
+
+ if (dsize) {
+ doubleconstpool->object->type = CDecl_NewArrayType(TYPE(&stdouble), dsize);
+ buffer = galloc(dsize);
+ for (entry = doubleconstpool; entry; entry = entry->next)
+ memcpy(buffer + entry->offset, entry->buffer, 8);
+ CInit_DeclareReadOnlyData(doubleconstpool->object, buffer, NULL, dsize);
+ }
+
+ vsize = 0;
+ for (entry = vectorconstpool; entry; entry = entry->next)
+ vsize += 16;
+
+ if (vsize) {
+ vectorconstpool->object->type = CDecl_NewArrayType(TYPE(&stvectorsignedlong), vsize);
+ buffer = galloc(vsize);
+ for (entry = vectorconstpool; entry; entry = entry->next)
+ memcpy(buffer + entry->offset, entry->buffer, 16);
+ CInit_DeclareReadOnlyData(vectorconstpool->object, buffer, NULL, vsize);
+ }
}
-static Object *CreatePooledFloatConst(Type *type, Float *data, SInt32 *unkptr) {
- // TODO CDecl
+static Object *CreatePooledFloatConst(Type *type, Float *data, SInt32 *pOffset) {
+ if (type->size == 8u) {
+ PoolEntry *entry;
+ void *buffer;
+ Object *object;
+ SInt32 offset;
+
+ buffer = galloc(8u);
+ CMach_InitFloatMem(type, *data, buffer);
+ if (cparamblkptr->isPrecompiling == 1)
+ CError_Error(CErrorStr180);
+
+ for (entry = doubleconstpool; entry; entry = entry->next) {
+ if (!memcmp(entry->buffer, buffer, 8u))
+ break;
+ }
+
+ if (!entry) {
+ if (doubleconstpool) {
+ object = doubleconstpool->object;
+ offset = doubleconstpool->offset + 8u;
+ doubleconstpool->object->type->size += 8u;
+ } else {
+ DeclInfo di;
+ memclrw(&di, sizeof(di));
+ di.thetype = CDecl_NewArrayType(TYPE(&stdouble), 8u);
+ di.name = GetHashNameNodeExport("@doubleBase0");
+ di.qual = Q_CONST;
+ di.storageclass = TK_STATIC;
+ di.x4E = 1;
+ di.section = SECT_CONST;
+ object = CParser_NewGlobalDataObject(&di);
+ object->nspace = cscope_root;
+ offset = 0;
+ }
+
+ entry = galloc(sizeof(PoolEntry));
+ entry->next = doubleconstpool;
+ doubleconstpool = entry;
+ entry->object = object;
+ entry->offset = offset;
+ entry->buffer = galloc(8u);
+ memcpy(entry->buffer, buffer, 8u);
+ }
+
+ *pOffset = entry->offset;
+ return entry->object;
+ }
+
+ if (type->size == 4u) {
+ PoolEntry *entry;
+ void *buffer;
+ Object *object;
+ SInt32 offset;
+
+ buffer = galloc(4u);
+ CMach_InitFloatMem(type, *data, buffer);
+ if (cparamblkptr->isPrecompiling == 1)
+ CError_Error(CErrorStr180);
+
+ for (entry = floatconstpool; entry; entry = entry->next) {
+ if (!memcmp(entry->buffer, buffer, 4u))
+ break;
+ }
+
+ if (!entry) {
+ if (floatconstpool) {
+ object = floatconstpool->object;
+ offset = floatconstpool->offset + 4u;
+ object->type->size += 4u;
+ } else {
+ DeclInfo di;
+ memclrw(&di, sizeof(di));
+ di.thetype = CDecl_NewArrayType(TYPE(&stfloat), 4u);
+ di.name = GetHashNameNodeExport("@floatBase0");
+ di.qual = Q_CONST;
+ di.storageclass = TK_STATIC;
+ di.x4E = 1;
+ di.section = SECT_CONST;
+ object = CParser_NewGlobalDataObject(&di);
+ object->nspace = cscope_root;
+ offset = 0;
+ }
+
+ entry = galloc(sizeof(PoolEntry));
+ entry->next = floatconstpool;
+ floatconstpool = entry;
+ entry->object = object;
+ entry->offset = offset;
+ entry->buffer = galloc(4u);
+ memcpy(entry->buffer, buffer, 4u);
+ }
+
+ *pOffset = entry->offset;
+ return entry->object;
+ }
+
+ CError_FATAL(1183);
+ return NULL;
}
-Object *CreateFloatConst(Type *type, Float *data, SInt32 *unkptr) {
- *unkptr = 0;
+Object *CreateFloatConst(Type *type, Float *data, SInt32 *pOffset) {
+ *pOffset = 0;
return createfloatconstant(type, data);
}
@@ -281,7 +421,7 @@ static void RewriteFloatConst(ENode *expr) {
obj = CreateFloatConst(expr->rtype, &expr->data.floatval, &n);
if (n) {
- subexpr = makediadicnode(create_objectrefnode(obj), intconstnode(&stunsignedlong, n), EADD);
+ subexpr = makediadicnode(create_objectrefnode(obj), intconstnode(TYPE(&stunsignedlong), n), EADD);
} else {
subexpr = create_objectrefnode(obj);
}
@@ -293,8 +433,63 @@ static void RewriteFloatConst(ENode *expr) {
}
static void RewriteVectorConst(ENode *expr) {
+ PoolEntry *entry;
+ Object *object;
+ SInt32 offset;
+ ENode *inner;
UInt8 data[16];
- // TODO
+
+ CMach_InitVectorMem(expr->rtype, expr->data.vector128val, data, 1);
+
+ if (cparamblkptr->isPrecompiling == 1)
+ CError_Error(CErrorStr180);
+
+ for (entry = vectorconstpool; entry; entry = entry->next) {
+ if (!memcmp(entry->buffer, data, 16))
+ break;
+ }
+
+ if (!entry) {
+ if (vectorconstpool) {
+ object = vectorconstpool->object;
+ offset = vectorconstpool->offset + 16;
+ vectorconstpool->object->type->size += 16;
+ } else {
+ DeclInfo di;
+ memclrw(&di, sizeof(di));
+ di.thetype = CDecl_NewArrayType(TYPE(&stvectorsignedlong), 16);
+ di.name = GetHashNameNodeExport("@vectorBase0");
+ di.qual = Q_CONST;
+ di.storageclass = TK_STATIC;
+ di.x4E = 1;
+ di.section = SECT_CONST;
+ object = CParser_NewGlobalDataObject(&di);
+ object->nspace = cscope_root;
+ offset = 0;
+ }
+
+ entry = galloc(sizeof(PoolEntry));
+ entry->next = vectorconstpool;
+ vectorconstpool = entry;
+ entry->object = object;
+ entry->offset = offset;
+ entry->buffer = galloc(16);
+ memcpy(entry->buffer, data, 16);
+ }
+
+ if (entry->offset) {
+ inner = makediadicnode(
+ create_objectrefnode(entry->object),
+ intconstnode(TYPE(&stunsignedlong), entry->offset),
+ EADD);
+ } else {
+ inner = create_objectrefnode(entry->object);
+ }
+
+ expr->type = EINDIRECT;
+ expr->cost = 1;
+ expr->flags |= ENODE_FLAG_CONST;
+ expr->data.monadic = inner;
}
static Object *createcodelabel(CLabel *label) {
@@ -313,7 +508,7 @@ static Object *createcodelabel(CLabel *label) {
obj->name = label->uniquename;
obj->toc = NULL;
obj->u.data.info = NULL; // not sure if this is the right union!
- obj->sclass = OBJECT_SCLASS_102;
+ obj->sclass = TK_STATIC;
obj->qual = Q_CONST;
obj->datatype = DDATA;
obj->flags |= OBJECT_FLAGS_2 | OBJECT_FLAGS_4;
@@ -748,9 +943,13 @@ Boolean canoptimizevectorconst(MWVector128 *vecp, Type *type, COVCResult *result
first8 = vec.sc[0];
flag = 1;
- for (i = 0; flag && i < 16; i++) {
+ i = 1;
+ while (flag && i < 16)
+ flag = first8 == vec.sc[i++];
+ /*flag = 1;
+ for (i = 1; flag && i < 16; i++) {
flag = first8 == vec.sc[i];
- }
+ }*/
if (flag && first8 < 16 && first8 > -17) {
if (result) {
@@ -954,6 +1153,12 @@ static Boolean DetectCondSideAffect(ENode *expr) {
case EXOR:
case EOR:
case ECOMMA:
+ case EPMODULO:
+ case EROTL:
+ case EROTR:
+ case EBCLR:
+ case EBTST:
+ case EBSET:
if (DetectCondSideAffect(expr->data.diadic.left))
return 1;
return DetectCondSideAffect(expr->data.diadic.right);
@@ -961,7 +1166,7 @@ static Boolean DetectCondSideAffect(ENode *expr) {
if (expr->data.monadic->type == EINDIRECT)
return 1;
if (expr->data.monadic->type == EOBJREF) {
- if (expr->data.monadic->data.objref->datatype != DDATA && expr->data.monadic->data.objref->datatype != DLOCAL)
+ if (expr->data.monadic->data.objref->datatype != DLOCAL && expr->data.monadic->data.objref->datatype != DDATA)
return 1;
if (IS_TYPE_POINTER(expr->data.monadic->data.objref->type))
return 1;
@@ -1509,12 +1714,12 @@ static void expandTOCexpression(ENode *expr, Type *type, int ignored) {
case EFUNCCALLP:
if (is_intrinsic_function_call(expr)) {
expr->hascall = 0;
- if ((expr->data.funccall.funcref->data.objref->u.func.u.intrinsicid & 0xFFFFu) == INTRINSIC_8) {
+ if ((expr->data.funccall.funcref->data.objref->u.func.u.intrinsicid & 0xFFFFu) == Intrinsic_008) {
if (copts.altivec_model)
update_frame_align(16);
dynamic_stack = 1;
requires_frame = 1;
- } else if ((expr->data.funccall.funcref->data.objref->u.func.u.intrinsicid & 0xFFFFu) == INTRINSIC_35) {
+ } else if ((expr->data.funccall.funcref->data.objref->u.func.u.intrinsicid & 0xFFFFu) == Intrinsic_035) {
if (expr->data.funccall.args->next->node->type == ESTRINGCONST) {
rewritestrcpy(expr);
} else {
@@ -1522,7 +1727,7 @@ static void expandTOCexpression(ENode *expr, Type *type, int ignored) {
makes_call = 1;
expr->hascall = 1;
}
- } else if ((expr->data.funccall.funcref->data.objref->u.func.u.intrinsicid & 0xFFFFu) == INTRINSIC_36) {
+ } else if ((expr->data.funccall.funcref->data.objref->u.func.u.intrinsicid & 0xFFFFu) == Intrinsic_036) {
if (expr->data.funccall.args->next->next->node->type != EINTCONST) {
requires_frame = 1;
makes_call = 1;
@@ -1929,6 +2134,10 @@ static void checkexceptionreferences(ExceptionAction *action) {
void expandTOCreferences(Statement **stmts) {
Statement *stmt;
+ IAOperand *op;
+ int i;
+ InlineAsm *ia;
+ VarInfo *vi;
codelabellist = NULL;
exceptionlist = NULL;
@@ -1952,7 +2161,7 @@ void expandTOCreferences(Statement **stmts) {
break;
case ST_IFGOTO:
case ST_IFNGOTO:
- if (stmt->expr->type >= ELESS && stmt->expr->type <= ENOTEQU)
+ if (stmt->expr->type < ELESS || stmt->expr->type > ENOTEQU)
stmt->expr = comparewithzero(stmt->expr);
expandTOCexpression(stmt->expr, NULL, 0);
break;
@@ -1973,8 +2182,29 @@ void expandTOCreferences(Statement **stmts) {
makes_call = 1;
break;
case ST_ASM:
- if (stmt->expr) {
- // TODO - ASM weirdness here
+ if ((ia = (InlineAsm *) stmt->expr)) {
+ if (ia->flags & IAFlag1) {
+ if (ia->opcode == IADirective_FrFree)
+ requires_frame = 1;
+ } else {
+ for (i = 0, op = ia->args; i < ia->argcount; i++, op++) {
+ if (op->type == IAOpnd_Reg) {
+ if (!op->u.reg.object) {
+ if (op->u.reg.num == INVALID_PIC_REG)
+ uses_globals = 1;
+ else if (op->u.reg.effect & EffectWrite)
+ asm_used_register(op->u.reg.rclass, op->u.reg.num);
+ } else if ((vi = Registers_GetVarInfo(op->u.reg.object))) {
+ vi->flags |= VarInfoFlag40;
+ }
+ } else if (op->type == IAOpnd_3) {
+ uses_globals = 1;
+ }
+ }
+
+ if (ia->flags & IAFlag2)
+ makes_call = 1;
+ }
}
break;
}
@@ -2021,7 +2251,7 @@ Object *createstaticinitobject(void) {
obj->otype = OT_OBJECT;
obj->type = (Type *) tfunc;
obj->name = GetHashNameNodeExport(buf);
- obj->sclass = OBJECT_SCLASS_102;
+ obj->sclass = TK_STATIC;
obj->datatype = DFUNC;
return obj;
--
cgit v1.2.3