summaryrefslogtreecommitdiff
path: root/compiler_and_linker/FrontEnd/C/CABI.c
diff options
context:
space:
mode:
Diffstat (limited to 'compiler_and_linker/FrontEnd/C/CABI.c')
-rw-r--r--compiler_and_linker/FrontEnd/C/CABI.c2033
1 files changed, 2033 insertions, 0 deletions
diff --git a/compiler_and_linker/FrontEnd/C/CABI.c b/compiler_and_linker/FrontEnd/C/CABI.c
new file mode 100644
index 0000000..2a88de1
--- /dev/null
+++ b/compiler_and_linker/FrontEnd/C/CABI.c
@@ -0,0 +1,2033 @@
+#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/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"
+
+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;
+
+short CABI_GetStructResultArgumentIndex(TypeFunc *tfunc) {
+ return 0;
+}
+
+Type *CABI_GetSizeTType(void) {
+ return TYPE(&stunsignedlong);
+}
+
+Type *CABI_GetPtrDiffTType(void) {
+ return TYPE(&stsignedlong);
+}
+
+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->bitlength;
+ a = tbitfield->offset;
+ tbitfield->offset = (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(ClassLayout *layout, 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_EMPTY)) {
+ 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(ClassLayout *layout, 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;
+}
+
+static SInt32 CABI_GetMemberOffset(TypeClass *tclass, HashNameNode *name) {
+ ObjMemberVar *ivar;
+
+ 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(ClassLayout *layout, 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_UNION)
+ 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_UNION) {
+ 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_UNION)
+ CMach_StructLayoutInitOffset(initialSize);
+
+ unionStart = CMach_StructLayoutGetOffset(ivar->type, ivar->qual);
+ unionClass = TYPE_CLASS(ivar->type);
+ inAnonUnion = 1;
+
+ if (tclass->mode == CLASS_MODE_UNION) {
+ SInt32 tmp = CMach_StructLayoutGetCurSize();
+ if (tmp > maxSize)
+ maxSize = tmp;
+ }
+
+ removeNoNameIvars = 1;
+ }
+
+ if (layout->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_UNION)
+ 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(ClassLayout *layout, 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 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));
+ memclrw(tclass->vtable, sizeof(VTable));
+}
+
+SInt32 CABI_GetVTableOffset(TypeClass *tclass) {
+ return 0;
+}
+
+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 = obj->flags | OBJECT_INTERNAL;
+ if (flags & CLASS_EFLAGS_IMPORT)
+ obj->flags = obj->flags | OBJECT_IMPORT;
+ if (flags & CLASS_EFLAGS_EXPORT)
+ obj->flags = obj->flags | OBJECT_EXPORT;
+}
+
+static void CABI_AllocateVTable(ClassLayout *layout, TypeClass *tclass) {
+ SInt32 size;
+ ObjBase *objbase;
+ Object *obj;
+ ObjMemberVar *ivar;
+ ClassList *base;
+ VClassList *vbase;
+ int i;
+
+ size = 0;
+
+ if (!tclass->vtable) {
+ CABI_AddVTable(tclass);
+ layout->xA = layout->lex_order_count - 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);
+ layout->vtable_ivar = ivar;
+
+ for (i = layout->xA; ; i--) {
+ if (i < 0) {
+ ivar->next = tclass->ivars;
+ tclass->ivars = ivar;
+ break;
+ }
+
+ CError_ASSERT(666, layout->objlist[i]);
+
+ if (layout->objlist[i]->otype == OT_MEMBERVAR) {
+ ivar->next = OBJ_MEMBER_VAR(layout->objlist[i])->next;
+ OBJ_MEMBER_VAR(layout->objlist[i])->next = ivar;
+ break;
+ }
+ }
+
+ if (tclass->flags & (CLASS_SINGLE_OBJECT | CLASS_COM_OBJECT))
+ size = void_ptr.size;
+ else
+ size = 8;
+ } else {
+ layout->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 < layout->lex_order_count; i++) {
+ CError_ASSERT(714, objbase = layout->objlist[i]);
+
+ if (objbase->otype == OT_OBJECT && OBJECT(objbase)->datatype == DVFUNC) {
+ TypeMemberFunc *tmethod = TYPE_METHOD(OBJECT(objbase)->type);
+ Object *baseobj = CABI_FindZeroVirtualBaseMember(tclass, OBJECT(objbase));
+
+ if (baseobj) {
+ tmethod->vtbl_index = TYPE_METHOD(baseobj->type)->vtbl_index;
+ } else {
+ tmethod->vtbl_index = 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(ClassLayout *layout, TypeClass *tclass) {
+ char saveAlignMode = copts.structalignment;
+
+ tclass->size = 0;
+ if (!tclass->sominfo) {
+ if (tclass->bases)
+ CABI_AllocateBases(layout, tclass);
+ if (tclass->flags & CLASS_HAS_VBASES)
+ CABI_AllocateVirtualBasePointers(layout, tclass);
+ if (layout->has_vtable)
+ CABI_AllocateVTable(layout, tclass);
+ CABI_AllocateMembers(layout, tclass);
+ if (tclass->flags & CLASS_HAS_VBASES)
+ CABI_AllocateVirtualBases(layout, tclass);
+ } else {
+ copts.structalignment = AlignMode2_PPC;
+ CABI_AllocateMembers(layout, tclass);
+ }
+
+ tclass->align = CMach_GetClassAlign(tclass);
+ if (tclass->size == 0) {
+ tclass->size = 1;
+ tclass->flags = tclass->flags | CLASS_EMPTY;
+ } else {
+ tclass->size += CABI_StructSizeAlignValue(TYPE(tclass), tclass->size);
+ }
+
+ tclass->flags = tclass->flags | CLASS_COMPLETED;
+
+ copts.structalignment = saveAlignMode;
+}
+
+void CABI_MakeDefaultArgConstructor(TypeClass *tclass, Object *func) {
+ DefArgCtorInfo *info;
+ Boolean saveDebugInfo;
+ ENodeList *copied;
+ ENodeList *argexprs;
+ FuncArg *args;
+ 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.filesyminfo;
+ copts.filesyminfo = 0;
+
+ CFunc_SetupNewFuncArgs(func, TYPE_FUNC(func->type)->args);
+
+ if (tclass->flags & CLASS_HAS_VBASES)
+ 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_HAS_VBASES) {
+ 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.filesyminfo = 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_HANDLEOBJECT)
+ 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_HAS_VBASES))
+ 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.structalignment;
+ if (tclass->eflags & CLASS_EFLAGS_F0)
+ copts.structalignment = ((tclass->eflags & CLASS_EFLAGS_F0) >> 4) - 1;
+ size += CMach_MemberAlignValue(TYPE(&stunsignedlong), size);
+ copts.structalignment = 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;
+ NameResult pr;
+
+ if (!tclass->sominfo && (tclass->flags & CLASS_HANDLEOBJECT)) {
+ 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_HAS_VBASES) {
+ 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.filesyminfo;
+ copts.filesyminfo = 0;
+
+ CFunc_SetupNewFuncArgs(func, TYPE_FUNC(func->type)->args);
+
+ ctor_chain = NULL;
+ if (tclass->flags & CLASS_HAS_VBASES)
+ 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.filesyminfo = 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_EMPTY) {
+ 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; i++, offset += type->size) {
+ 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.filesyminfo;
+ copts.filesyminfo = 0;
+
+ CFunc_SetupNewFuncArgs(func, TYPE_FUNC(func->type)->args);
+
+ ctor_chain = NULL;
+ if (tclass->flags & CLASS_HAS_VBASES)
+ 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.filesyminfo = 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.filesyminfo;
+ copts.filesyminfo = 0;
+
+ CFunc_SetupNewFuncArgs(func, TYPE_FUNC(func->type)->args);
+
+ stmt = curstmt;
+
+ if (tclass->mode == CLASS_MODE_UNION) {
+ 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.filesyminfo = 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 = 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;
+
+ base = bases;
+ count = 0;
+ while (base) {
+ base = base->next;
+ count++;
+ }
+
+ while (count > 0) {
+ base = bases;
+ i = count;
+ while (i-- > 1)
+ 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_HANDLEOBJECT))
+ scan = CABI_DestroyMembers(scan, tclass->ivars, tclass);
+
+ if (flag25 && tclass->bases)
+ scan = CABI_DestroyBases(scan, tclass->bases);
+
+ if (flag24 && (tclass->flags & CLASS_HAS_VBASES)) {
+ 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.filesyminfo;
+ copts.filesyminfo = 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.filesyminfo = 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.filesyminfo;
+ copts.filesyminfo = 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.filesyminfo = 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(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_MANGLE_NAME;
+ func->qual |= Q_INLINE;
+ CABI_ApplyClassFlags(func, tclass->eflags, 1);
+
+ CError_ASSERT(2678, IS_TYPE_FUNC(func->type));
+ TYPE_FUNC(func->type)->flags |= FUNC_AUTO_GENERATED;
+
+ if (dtor->datatype == DVFUNC) {
+ func->datatype = DVFUNC;
+ CMangler_GetLinkName(func);
+ func->datatype = DFUNC;
+ }
+
+ 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 = expr->data.funccall.funcref->flags | ENODE_FLAG_80;
+ expr->data.funccall.functype = TYPE_FUNC(dtor->type);
+ dtor->flags = dtor->flags | OBJECT_USED;
+
+ 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;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-21 21:45:32 +0000