a bunch of compiler stuff

1 files changed, 1499 insertions, 0 deletions

diff --git a/compiler_and_linker/unsorted/CMachine.c b/compiler_and_linker/unsorted/CMachine.c
new file mode 100644
index 0000000..f34ec88
--- /dev/null
+++ b/compiler_and_linker/unsorted/CMachine.c
@@ -0,0 +1,1499 @@
+#include "compiler.h"
+#include "compiler/CError.h"
+#include "compiler/CInt64.h"
+#include "compiler/objects.h"
+#include "compiler/types.h"
+
+TypeIntegral stbool = {TYPEINT, 0, IT_BOOL};
+TypeIntegral stchar = {TYPEINT, 1, IT_CHAR};
+TypeIntegral stsignedchar = {TYPEINT, 0, IT_SCHAR};
+TypeIntegral stunsignedchar = {TYPEINT, 0, IT_UCHAR};
+TypeIntegral stwchar = {TYPEINT, 4, IT_WCHAR_T};
+TypeIntegral stsignedshort = {TYPEINT, 2, IT_SHORT};
+TypeIntegral stunsignedshort = {TYPEINT, 2, IT_USHORT};
+TypeIntegral stsignedint = {TYPEINT, 4, IT_INT};
+TypeIntegral stunsignedint = {TYPEINT, 4, IT_UINT};
+TypeIntegral stsignedlong = {TYPEINT, 4, IT_LONG};
+TypeIntegral stunsignedlong = {TYPEINT, 4, IT_ULONG};
+TypeIntegral stsignedlonglong = {TYPEINT, 8, IT_LONGLONG};
+TypeIntegral stunsignedlonglong = {TYPEINT, 8, IT_ULONGLONG};
+TypeIntegral stfloat = {TYPEFLOAT, 4, IT_FLOAT};
+TypeIntegral stshortdouble = {TYPEINT, 8, IT_SHORTDOUBLE};
+TypeIntegral stdouble = {TYPEINT, 8, IT_DOUBLE};
+TypeIntegral stlongdouble = {TYPEINT, 8, IT_LONGDOUBLE};
+
+static StructMember stVUC_unsignedchar15 = {NULL, (Type *) &stunsignedchar, NULL, 15, 0};
+static StructMember stVUC_unsignedchar14 = {&stVUC_unsignedchar15, (Type *) &stunsignedchar, NULL, 14, 0};
+static StructMember stVUC_unsignedchar13 = {&stVUC_unsignedchar14, (Type *) &stunsignedchar, NULL, 13, 0};
+static StructMember stVUC_unsignedchar12 = {&stVUC_unsignedchar13, (Type *) &stunsignedchar, NULL, 12, 0};
+static StructMember stVUC_unsignedchar11 = {&stVUC_unsignedchar12, (Type *) &stunsignedchar, NULL, 11, 0};
+static StructMember stVUC_unsignedchar10 = {&stVUC_unsignedchar11, (Type *) &stunsignedchar, NULL, 10, 0};
+static StructMember stVUC_unsignedchar9 = {&stVUC_unsignedchar10, (Type *) &stunsignedchar, NULL, 9, 0};
+static StructMember stVUC_unsignedchar8 = {&stVUC_unsignedchar9, (Type *) &stunsignedchar, NULL, 8, 0};
+static StructMember stVUC_unsignedchar7 = {&stVUC_unsignedchar7, (Type *) &stunsignedchar, NULL, 7, 0};
+static StructMember stVUC_unsignedchar6 = {&stVUC_unsignedchar7, (Type *) &stunsignedchar, NULL, 6, 0};
+static StructMember stVUC_unsignedchar5 = {&stVUC_unsignedchar6, (Type *) &stunsignedchar, NULL, 5, 0};
+static StructMember stVUC_unsignedchar4 = {&stVUC_unsignedchar5, (Type *) &stunsignedchar, NULL, 4, 0};
+static StructMember stVUC_unsignedchar3 = {&stVUC_unsignedchar4, (Type *) &stunsignedchar, NULL, 3, 0};
+static StructMember stVUC_unsignedchar2 = {&stVUC_unsignedchar3, (Type *) &stunsignedchar, NULL, 2, 0};
+static StructMember stVUC_unsignedchar1 = {&stVUC_unsignedchar2, (Type *) &stunsignedchar, NULL, 1, 0};
+static StructMember stVUC_unsignedchar0 = {&stVUC_unsignedchar1, (Type *) &stunsignedchar, NULL, 0, 0};
+
+static StructMember stVSC_signedchar15 = {NULL, (Type *) &stsignedchar, NULL, 15, 0};
+static StructMember stVSC_signedchar14 = {&stVSC_signedchar15, (Type *) &stsignedchar, NULL, 14, 0};
+static StructMember stVSC_signedchar13 = {&stVSC_signedchar14, (Type *) &stsignedchar, NULL, 13, 0};
+static StructMember stVSC_signedchar12 = {&stVSC_signedchar13, (Type *) &stsignedchar, NULL, 12, 0};
+static StructMember stVSC_signedchar11 = {&stVSC_signedchar12, (Type *) &stsignedchar, NULL, 11, 0};
+static StructMember stVSC_signedchar10 = {&stVSC_signedchar11, (Type *) &stsignedchar, NULL, 10, 0};
+static StructMember stVSC_signedchar9 = {&stVSC_signedchar10, (Type *) &stsignedchar, NULL, 9, 0};
+static StructMember stVSC_signedchar8 = {&stVSC_signedchar9, (Type *) &stsignedchar, NULL, 8, 0};
+static StructMember stVSC_signedchar7 = {&stVSC_signedchar7, (Type *) &stsignedchar, NULL, 7, 0};
+static StructMember stVSC_signedchar6 = {&stVSC_signedchar7, (Type *) &stsignedchar, NULL, 6, 0};
+static StructMember stVSC_signedchar5 = {&stVSC_signedchar6, (Type *) &stsignedchar, NULL, 5, 0};
+static StructMember stVSC_signedchar4 = {&stVSC_signedchar5, (Type *) &stsignedchar, NULL, 4, 0};
+static StructMember stVSC_signedchar3 = {&stVSC_signedchar4, (Type *) &stsignedchar, NULL, 3, 0};
+static StructMember stVSC_signedchar2 = {&stVSC_signedchar3, (Type *) &stsignedchar, NULL, 2, 0};
+static StructMember stVSC_signedchar1 = {&stVSC_signedchar2, (Type *) &stsignedchar, NULL, 1, 0};
+static StructMember stVSC_signedchar0 = {&stVSC_signedchar1, (Type *) &stsignedchar, NULL, 0, 0};
+
+static StructMember stVUS_unsignedshort7 = {NULL, (Type *) &stunsignedshort, NULL, 14, 0};
+static StructMember stVUS_unsignedshort6 = {&stVUS_unsignedshort7, (Type *) &stunsignedshort, NULL, 12, 0};
+static StructMember stVUS_unsignedshort5 = {&stVUS_unsignedshort7, (Type *) &stunsignedshort, NULL, 10, 0};
+static StructMember stVUS_unsignedshort4 = {&stVUS_unsignedshort5, (Type *) &stunsignedshort, NULL, 8, 0};
+static StructMember stVUS_unsignedshort3 = {&stVUS_unsignedshort4, (Type *) &stunsignedshort, NULL, 6, 0};
+static StructMember stVUS_unsignedshort2 = {&stVUS_unsignedshort3, (Type *) &stunsignedshort, NULL, 4, 0};
+static StructMember stVUS_unsignedshort1 = {&stVUS_unsignedshort2, (Type *) &stunsignedshort, NULL, 2, 0};
+static StructMember stVUS_unsignedshort0 = {&stVUS_unsignedshort1, (Type *) &stunsignedshort, NULL, 0, 0};
+
+static StructMember stVSS_signedshort7 = {NULL, (Type *) &stsignedshort, NULL, 14, 0};
+static StructMember stVSS_signedshort6 = {&stVSS_signedshort7, (Type *) &stsignedshort, NULL, 12, 0};
+static StructMember stVSS_signedshort5 = {&stVSS_signedshort7, (Type *) &stsignedshort, NULL, 10, 0};
+static StructMember stVSS_signedshort4 = {&stVSS_signedshort5, (Type *) &stsignedshort, NULL, 8, 0};
+static StructMember stVSS_signedshort3 = {&stVSS_signedshort4, (Type *) &stsignedshort, NULL, 6, 0};
+static StructMember stVSS_signedshort2 = {&stVSS_signedshort3, (Type *) &stsignedshort, NULL, 4, 0};
+static StructMember stVSS_signedshort1 = {&stVSS_signedshort2, (Type *) &stsignedshort, NULL, 2, 0};
+static StructMember stVSS_signedshort0 = {&stVSS_signedshort1, (Type *) &stsignedshort, NULL, 0, 0};
+
+static StructMember stVUL_unsignedlong3 = {NULL, (Type *) &stunsignedlong, NULL, 12, 0};
+static StructMember stVUL_unsignedlong2 = {&stVUL_unsignedlong3, (Type *) &stunsignedlong, NULL, 8, 0};
+static StructMember stVUL_unsignedlong1 = {&stVUL_unsignedlong2, (Type *) &stunsignedlong, NULL, 4, 0};
+static StructMember stVUL_unsignedlong0 = {&stVUL_unsignedlong1, (Type *) &stunsignedlong, NULL, 0, 0};
+
+static StructMember stVSL_signedlong3 = {NULL, (Type *) &stsignedlong, NULL, 12, 0};
+static StructMember stVSL_signedlong2 = {&stVSL_signedlong3, (Type *) &stsignedlong, NULL, 8, 0};
+static StructMember stVSL_signedlong1 = {&stVSL_signedlong2, (Type *) &stsignedlong, NULL, 4, 0};
+static StructMember stVSL_signedlong0 = {&stVSL_signedlong1, (Type *) &stsignedlong, NULL, 0, 0};
+
+static StructMember stVF_float3 = {NULL, (Type *) &stfloat, NULL, 12, 0};
+static StructMember stVF_float2 = {&stVF_float3, (Type *) &stfloat, NULL, 8, 0};
+static StructMember stVF_float1 = {&stVF_float2, (Type *) &stfloat, NULL, 4, 0};
+static StructMember stVF_float0 = {&stVF_float1, (Type *) &stfloat, NULL, 0, 0};
+
+TypeStruct stvectorunsignedchar = {TYPESTRUCT, 16, NULL, &stVUC_unsignedchar0, STRUCT_TYPE_4, 16};
+TypeStruct stvectorsignedchar = {TYPESTRUCT, 16, NULL, &stVSC_signedchar0, STRUCT_TYPE_5, 16};
+TypeStruct stvectorboolchar = {TYPESTRUCT, 16, NULL, &stVSC_signedchar0, STRUCT_TYPE_6, 16};
+
+TypeStruct stvectorunsignedshort = {TYPESTRUCT, 16, NULL, &stVUS_unsignedshort0, STRUCT_TYPE_7, 16};
+TypeStruct stvectorsignedshort = {TYPESTRUCT, 16, NULL, &stVSS_signedshort0, STRUCT_TYPE_8, 16};
+TypeStruct stvectorboolshort = {TYPESTRUCT, 16, NULL, &stVSS_signedshort0, STRUCT_TYPE_9, 16};
+
+TypeStruct stvectorunsignedlong = {TYPESTRUCT, 16, NULL, &stVUL_unsignedlong0, STRUCT_TYPE_A, 16};
+TypeStruct stvectorsignedlong = {TYPESTRUCT, 16, NULL, &stVSL_signedlong0, STRUCT_TYPE_B, 16};
+TypeStruct stvectorboollong = {TYPESTRUCT, 16, NULL, &stVSL_signedlong0, STRUCT_TYPE_C, 16};
+
+TypeStruct stvectorfloat = {TYPESTRUCT, 16, NULL, &stVF_float0, STRUCT_TYPE_D, 16};
+
+TypeStruct stvectorpixel = {TYPESTRUCT, 16, NULL, &stVUS_unsignedshort0, STRUCT_TYPE_E, 16};
+
+TypeStruct stvector = {TYPESTRUCT, 16, NULL, NULL, STRUCT_TYPE_A, 16};
+
+static SInt32 cmach_structoffset;
+static UInt8 cmach_structalign;
+static short cmach_curbfsize;
+static short cmach_curbfbasesize;
+static int cmach_curbfoffset;
+
+static short cmach_packsize[] = {
+        1, 2, 4, 8, 16
+};
+
+// forward declarations
+static SInt16 CMach_GetQualifiedTypeAlign(Type *type, Boolean flag);
+static SInt16 CMach_GetMemberAlignment(Type *type, SInt32 align, Boolean flag);
+
+void CMach_Configure() {
+}
+
+SInt32 CMach_GetQUALalign(UInt32 qual) {
+    SInt32 result = 0;
+    SInt32 chk;
+
+    if ((chk = (qual & Q_ALIGNED_MASK))) {
+        if (chk == Q_ALIGNED_1)
+            result = 1;
+        else if (chk == Q_ALIGNED_2)
+            result = 2;
+        else if (chk == Q_ALIGNED_4)
+            result = 4;
+        else if (chk == Q_ALIGNED_8)
+            result = 8;
+        else if (chk == Q_ALIGNED_16)
+            result = 16;
+        else if (chk == Q_ALIGNED_32)
+            result = 32;
+        else if (chk == Q_ALIGNED_64)
+            result = 64;
+        else if (chk == Q_ALIGNED_128)
+            result = 128;
+        else if (chk == Q_ALIGNED_256)
+            result = 256;
+        else if (chk == Q_ALIGNED_512)
+            result = 512;
+        else if (chk == Q_ALIGNED_1024)
+            result = 1024;
+        else if (chk == Q_ALIGNED_2048)
+            result = 2048;
+        else if (chk == Q_ALIGNED_4096)
+            result = 4096;
+        else if (chk == Q_ALIGNED_8192)
+            result = 8192;
+        else {
+#line 226
+            CError_FATAL();
+        }
+    }
+
+    return result;
+}
+
+SInt32 CMach_ArgumentAlignment(Type *type) {
+    // does not match - registers
+    UInt8 save_align_mode;
+    UInt8 save_oldalignment;
+    SInt32 align;
+
+    save_align_mode = copts.align_mode;
+    save_oldalignment = copts.oldalignment;
+    copts.align_mode = AlignMode2_PPC;
+    copts.oldalignment = 0;
+    align = CMach_GetQualifiedTypeAlign(type, 0);
+    copts.align_mode = save_align_mode;
+    copts.oldalignment = save_oldalignment;
+
+    if (type->type == TYPESTRUCT && !TYPE_STRUCT(type)->members && TYPE_STRUCT(type)->align > align)
+        align = TYPE_STRUCT(type)->align;
+
+    return align;
+}
+
+SInt32 CMach_AllocationAlignment(Type *type, UInt32 qual) {
+    SInt32 align;
+    SInt32 qualalign;
+    SInt32 argalign;
+    SInt32 anotheralign;
+
+    qualalign = CMach_GetQUALalign(qual);
+    align = CMach_GetQualifiedTypeAlign(type, 1);
+    if (qualalign > align)
+        align = qualalign;
+    argalign = CMach_ArgumentAlignment(type);
+    if (argalign > align)
+        align = argalign;
+
+    switch (type->type) {
+        case TYPEVOID:
+        case TYPEMEMBERPOINTER:
+        case TYPEPOINTER:
+            anotheralign = 4;
+            break;
+        default:
+            anotheralign = 1;
+    }
+    if (anotheralign > align)
+        align = anotheralign;
+
+    if (copts.optimizationlevel > 0) {
+        if (type->type == TYPEARRAY || (type->type == TYPESTRUCT && (TYPE_STRUCT(type)->stype < STRUCT_TYPE_4 || TYPE_STRUCT(type)->stype > STRUCT_TYPE_E)) || type->type == TYPECLASS || (type->type == TYPEMEMBERPOINTER && (UInt32) type->size == 12)) {
+            return (copts.some_alignment > align) ? copts.some_alignment : align;
+        }
+    }
+
+    return align;
+}
+
+CInt64 CMach_CalcIntDiadic(Type *type, CInt64 left, short op, CInt64 right) {
+    if (is_unsigned(type)) {
+        switch (type->size) {
+            case 1:
+                CInt64_ConvertUInt8(&left);
+                CInt64_ConvertUInt8(&right);
+                break;
+            case 2:
+                CInt64_ConvertUInt16(&left);
+                CInt64_ConvertUInt16(&right);
+                break;
+            case 4:
+                CInt64_ConvertUInt32(&left);
+                CInt64_ConvertUInt32(&right);
+                break;
+            case 8:
+                break;
+            default:
+#line 327
+                CError_FATAL();
+        }
+
+        switch (op) {
+            case '*':
+                left = CInt64_MulU(left, right);
+                break;
+            case '/':
+                if (CInt64_IsZero(&right))
+                    CError_Warning(139);
+                else
+                    left = CInt64_DivU(left, right);
+                break;
+            case '%':
+                if (CInt64_IsZero(&right))
+                    CError_Warning(139);
+                else
+                    left = CInt64_ModU(left, right);
+                break;
+            case '+':
+                left = CInt64_Add(left, right);
+                break;
+            case '-':
+                left = CInt64_Sub(left, right);
+                break;
+            case TK_SHL:
+                left = CInt64_Shl(left, right);
+                break;
+            case TK_SHR:
+                left = CInt64_ShrU(left, right);
+                break;
+            case '<':
+                CInt64_SetLong(&left, CInt64_LessU(left, right));
+                break;
+            case '>':
+                CInt64_SetLong(&left, CInt64_GreaterU(left, right));
+                break;
+            case TK_LESS_EQUAL:
+                CInt64_SetLong(&left, CInt64_LessEqualU(left, right));
+                break;
+            case TK_GREATER_EQUAL:
+                CInt64_SetLong(&left, CInt64_GreaterEqualU(left, right));
+                break;
+            case TK_LOGICAL_EQ:
+                CInt64_SetLong(&left, CInt64_Equal(left, right));
+                break;
+            case TK_LOGICAL_NE:
+                CInt64_SetLong(&left, CInt64_NotEqual(left, right));
+                break;
+            case '&':
+                left = CInt64_And(left, right);
+                break;
+            case '^':
+                left = CInt64_Xor(left, right);
+                break;
+            case '|':
+                left = CInt64_Or(left, right);
+                break;
+            case TK_LOGICAL_AND:
+                CInt64_SetLong(&left, (CInt64_IsZero(&left) == 0 && CInt64_IsZero(&right) == 0));
+                break;
+            case TK_LOGICAL_OR:
+                CInt64_SetLong(&left, (CInt64_IsZero(&left) == 0 || CInt64_IsZero(&right) == 0));
+                break;
+            default:
+                CError_Error(120);
+        }
+
+        switch (type->size) {
+            case 1:
+                CInt64_ConvertUInt8(&left);
+                break;
+            case 2:
+                CInt64_ConvertUInt16(&left);
+                break;
+            case 4:
+                CInt64_ConvertUInt32(&left);
+                break;
+            case 8:
+                break;
+        }
+    } else {
+        switch (type->size) {
+            case 1:
+                CInt64_ConvertInt8(&left);
+                CInt64_ConvertInt8(&right);
+                break;
+            case 2:
+                CInt64_ConvertInt16(&left);
+                CInt64_ConvertInt16(&right);
+                break;
+            case 4:
+                CInt64_ConvertInt32(&left);
+                CInt64_ConvertInt32(&right);
+                break;
+            case 8:
+                break;
+            default:
+#line 389
+                CError_FATAL();
+        }
+
+        switch (op) {
+            case '*':
+                left = CInt64_Mul(left, right);
+                break;
+            case '/':
+                if (CInt64_IsZero(&right))
+                    CError_Warning(139);
+                else
+                    left = CInt64_Div(left, right);
+                break;
+            case '%':
+                if (CInt64_IsZero(&right))
+                    CError_Warning(139);
+                else
+                    left = CInt64_Mod(left, right);
+                break;
+            case '+':
+                left = CInt64_Add(left, right);
+                break;
+            case '-':
+                left = CInt64_Sub(left, right);
+                break;
+            case TK_SHL:
+                left = CInt64_Shl(left, right);
+                break;
+            case TK_SHR:
+                left = CInt64_Shr(left, right);
+                break;
+            case '<':
+                CInt64_SetLong(&left, CInt64_Less(left, right));
+                break;
+            case '>':
+                CInt64_SetLong(&left, CInt64_Greater(left, right));
+                break;
+            case TK_LESS_EQUAL:
+                CInt64_SetLong(&left, CInt64_LessEqual(left, right));
+                break;
+            case TK_GREATER_EQUAL:
+                CInt64_SetLong(&left, CInt64_GreaterEqual(left, right));
+                break;
+            case TK_LOGICAL_EQ:
+                CInt64_SetLong(&left, CInt64_Equal(left, right));
+                break;
+            case TK_LOGICAL_NE:
+                CInt64_SetLong(&left, CInt64_NotEqual(left, right));
+                break;
+            case '&':
+                left = CInt64_And(left, right);
+                break;
+            case '^':
+                left = CInt64_Xor(left, right);
+                break;
+            case '|':
+                left = CInt64_Or(left, right);
+                break;
+            case TK_LOGICAL_AND:
+                CInt64_SetLong(&left, (CInt64_IsZero(&left) == 0 && CInt64_IsZero(&right) == 0));
+                break;
+            case TK_LOGICAL_OR:
+                CInt64_SetLong(&left, (CInt64_IsZero(&left) == 0 || CInt64_IsZero(&right) == 0));
+                break;
+            default:
+                CError_Error(120);
+        }
+
+        switch (type->size) {
+            case 1:
+                CInt64_ConvertInt8(&left);
+                break;
+            case 2:
+                CInt64_ConvertInt16(&left);
+                break;
+            case 4:
+                CInt64_ConvertInt32(&left);
+                break;
+            case 8:
+                break;
+        }
+    }
+
+    return left;
+}
+
+CInt64 CMach_CalcIntMonadic(Type *type, short op, CInt64 val) {
+    if (is_unsigned(type)) {
+        switch (type->size) {
+            case 1:
+                CInt64_ConvertUInt8(&val);
+                break;
+            case 2:
+                CInt64_ConvertUInt16(&val);
+                break;
+            case 4:
+                CInt64_ConvertUInt32(&val);
+                break;
+            case 8:
+                break;
+            default:
+#line 448
+                CError_FATAL();
+        }
+
+        switch (op) {
+            case '-':
+                val = CInt64_Neg(val);
+                break;
+            case '~':
+                val = CInt64_Inv(val);
+                break;
+            case '!':
+                val = CInt64_Not(val);
+                break;
+            default:
+                CError_Error(120);
+        }
+
+        switch (type->size) {
+            case 1:
+                CInt64_ConvertUInt8(&val);
+                break;
+            case 2:
+                CInt64_ConvertUInt16(&val);
+                break;
+            case 4:
+                CInt64_ConvertUInt32(&val);
+                break;
+            case 8:
+                break;
+        }
+    } else {
+        switch (type->size) {
+            case 1:
+                CInt64_ConvertInt8(&val);
+                break;
+            case 2:
+                CInt64_ConvertInt16(&val);
+                break;
+            case 4:
+                CInt64_ConvertInt32(&val);
+                break;
+            case 8:
+                break;
+            default:
+#line 478
+                CError_FATAL();
+        }
+
+        switch (op) {
+            case '-':
+                val = CInt64_Neg(val);
+                break;
+            case '~':
+                val = CInt64_Inv(val);
+                break;
+            case '!':
+                val = CInt64_Not(val);
+                break;
+            default:
+                CError_Error(120);
+        }
+
+        switch (type->size) {
+            case 1:
+                CInt64_ConvertInt8(&val);
+                break;
+            case 2:
+                CInt64_ConvertInt16(&val);
+                break;
+            case 4:
+                CInt64_ConvertInt32(&val);
+                break;
+            case 8:
+                break;
+        }
+    }
+
+    return val;
+}
+
+CInt64 CMach_CalcIntConvertFromFloat(Type *type, Float fval) {
+    CInt64 result;
+
+    if ((type->type == TYPEINT || type->type == TYPEENUM) && (type->size == 8)) {
+        if (is_unsigned(type))
+            CInt64_ConvertUFromLongDouble(&result, fval.value);
+        else
+            CInt64_ConvertFromLongDouble(&result, fval.value);
+    } else {
+        if (is_unsigned(type))
+            CInt64_SetULong(&result, fval.value);
+        else
+            CInt64_SetLong(&result, fval.value);
+    }
+
+    return result;
+}
+
+void CMach_InitIntMem(Type *type, CInt64 val, void *mem) {
+    UInt32 lg;
+    UInt16 sh;
+    UInt8 ch;
+
+    switch (type->type) {
+        case TYPEINT:
+            switch (type->size) {
+                case 1:
+                    ch = (UInt8) val.lo;
+                    memcpy(mem, &ch, 1);
+                    break;
+                case 2:
+                    sh = (UInt16) val.lo;
+                    memcpy(mem, &sh, 2);
+                    break;
+                case 4:
+                    lg = (UInt32) val.lo;
+                    memcpy(mem, &lg, 4);
+                    break;
+                case 8:
+                    CTool_EndianConvertWord64(val, mem);
+                    break;
+                default:
+#line 566
+                    CError_FATAL();
+            }
+            break;
+        default:
+#line 570
+            CError_FATAL();
+    }
+}
+
+void CMach_InitVectorMem(Type *type, MWVector128 val, void *mem) {
+    unsigned char uc[16];
+    unsigned short us[8];
+    unsigned int ul[4];
+    float f[4];
+    int i;
+
+    switch (type->type) {
+        case TYPESTRUCT:
+            switch (TYPE_STRUCT(type)->stype) {
+                case STRUCT_TYPE_4:
+                case STRUCT_TYPE_5:
+                case STRUCT_TYPE_6:
+                    for (i = 0; i < 16; i++)
+                        uc[i] = val.uc[i];
+                    memcpy(mem, uc, 16);
+                    break;
+                case STRUCT_TYPE_7:
+                case STRUCT_TYPE_8:
+                case STRUCT_TYPE_9:
+                case STRUCT_TYPE_E:
+                    for (i = 0; i < 8; i++)
+                        us[i] = val.us[i];
+                    memcpy(mem, us, 16);
+                    break;
+                case STRUCT_TYPE_A:
+                case STRUCT_TYPE_B:
+                case STRUCT_TYPE_C:
+                    for (i = 0; i < 4; i++)
+                        ul[i] = val.ul[i];
+                    memcpy(mem, ul, 16);
+                    break;
+                case STRUCT_TYPE_D:
+                    for (i = 0; i < 4; i++)
+                        f[i] = val.f[i];
+                    memcpy(mem, f, 16);
+                    break;
+                default:
+#line 655
+                    CError_FATAL();
+            }
+            break;
+        default:
+#line 659
+            CError_FATAL();
+    }
+}
+
+Float CMach_CalcFloatDiadic(Type *type, Float left, short op, Float right) {
+    switch (op) {
+        case '+':
+            left.value += right.value;
+            break;
+        case '-':
+            left.value -= right.value;
+            break;
+        case '*':
+            left.value *= right.value;
+            break;
+        case '/':
+            left.value /= right.value;
+            break;
+        default:
+#line 679
+            CError_FATAL();
+    }
+
+    return CMach_CalcFloatConvert(type, left);
+}
+
+Float CMach_CalcFloatMonadic(Type *type, short op, Float fval) {
+    if (op != '-')
+#line 692
+        CError_FATAL();
+
+    fval.value = -fval.value;
+    return CMach_CalcFloatConvert(type, fval);
+}
+
+Boolean CMach_CalcFloatDiadicBool(Type *type, Float left, short op, Float right) {
+    switch (op) {
+        case TK_LOGICAL_EQ:
+            return left.value == right.value;
+        case TK_LOGICAL_NE:
+            return left.value != right.value;
+        case TK_LESS_EQUAL:
+            return left.value <= right.value;
+        case TK_GREATER_EQUAL:
+            return left.value >= right.value;
+        case '>':
+            return left.value > right.value;
+        case '<':
+            return left.value < right.value;
+        default:
+#line 714
+            CError_FATAL();
+            return 0;
+    }
+}
+
+Boolean CMach_CalcVectorDiadicBool(Type *type, MWVector128 *left, short op, MWVector128 *right) {
+    switch (op) {
+        case TK_LOGICAL_EQ:
+            return (left->ul[0] == right->ul[0]) && (left->ul[1] == right->ul[1]) && (left->ul[2] == right->ul[2]) && (left->ul[3] == right->ul[3]);
+        case TK_LOGICAL_NE:
+            return (left->ul[0] != right->ul[0]) && (left->ul[1] != right->ul[1]) && (left->ul[2] != right->ul[2]) && (left->ul[3] != right->ul[3]);
+        default:
+#line 740
+            CError_FATAL();
+            return 0;
+    }
+}
+
+char *CMach_FloatScan(char *input, Float *result, Boolean *fail) {
+    double resultval;
+    char *outpos;
+
+    if (!(outpos = ScanFloat(input, &resultval, fail)))
+        CError_ErrorTerm(154);
+
+    if (*fail)
+        result->value = 0.0;
+    else
+        result->value = resultval;
+
+    return outpos;
+}
+
+Float CMach_CalcFloatConvertFromInt(Type *type, CInt64 val) {
+    Float result;
+
+    if ((type->type == TYPEINT || type->type == TYPEENUM) && (type->size == 8)) {
+        if (is_unsigned(type))
+            result.value = CInt64_ConvertUToLongDouble(&val);
+        else
+            result.value = CInt64_ConvertToLongDouble(&val);
+    } else {
+        if (is_unsigned(type))
+            result.value = val.lo;
+        else
+            result.value = (SInt32) val.lo;
+    }
+
+    return result;
+}
+
+Float CMach_CalcFloatConvert(Type *type, Float fval) {
+    switch (type->size) {
+        case 4:
+            fval.value = (float) fval.value;
+            break;
+        case 8:
+            fval.value = (double) fval.value;
+            break;
+        case 10:
+        case 12:
+            break;
+        default:
+#line 801
+            CError_FATAL();
+    }
+    return fval;
+}
+
+Boolean CMach_FloatIsZero(Float fval) {
+    return fval.value == 0.0;
+}
+
+Boolean CMach_FloatIsOne(Float fval) {
+    return fval.value == 1.0;
+}
+
+Boolean CMach_FloatIsNegOne(Float fval) {
+    return fval.value == -1.0;
+}
+
+void CMach_InitFloatMem(Type *type, Float val, void *mem) {
+    float f;
+    double d;
+
+    if (type->type == TYPEFLOAT) {
+        switch (type->size) {
+            case 4:
+                f = val.value;
+                memcpy(mem, &f, 4);
+                return;
+            case 8:
+                d = val.value;
+                memcpy(mem, &d, 8);
+                return;
+        }
+    }
+
+#line 866
+    CError_FATAL();
+}
+
+void CMach_PrintFloat(char *buf, Float val) {
+    double f;
+    CMach_InitFloatMem((Type *) &stshortdouble, val, &f);
+    sprintf(buf, "%g", f);
+}
+
+void CMach_PragmaParams() {
+    if (copts.warn_illpragma)
+        CError_Warning(186, 0);
+
+    while (notendofline())
+        lex();
+}
+
+void CMach_AdjustFuntionArgs() {
+    // not called so we will never know what the args should have been :(
+}
+
+static SInt32 CMach_GetPPCTypeAlign(Type *type, Boolean flag1, Boolean flag2) {
+    ClassList *base;
+    ObjMemberVar *ivar;
+    StructMember *member;
+    SInt32 best;
+    SInt32 ivarAlign;
+    SInt32 qualAlign;
+
+    SInt32 align = CMach_GetQualifiedTypeAlign(type, flag2);
+    if (align <= 8) {
+        while (type->type == TYPEARRAY)
+            type = TYPE_POINTER(type)->target;
+
+        if (flag1) {
+            if (type->type == TYPEFLOAT && type->size > 4 && align < 8)
+                return 8;
+        } else if (align == 8) {
+            if (type->type == TYPECLASS) {
+                best = 4;
+                for (base = TYPE_CLASS(type)->bases; base; base = base->next) {
+                    if (base->base->align > best)
+                        best = base->base->align;
+                }
+                for (ivar = TYPE_CLASS(type)->ivars; ivar; ivar = ivar->next) {
+                    ivarAlign = CMach_GetPPCTypeAlign(ivar->type, 0, flag2);
+                    if (ivarAlign > best)
+                        best = ivarAlign;
+                    if (flag2) {
+                        qualAlign = CMach_GetQUALalign(ivar->qual);
+                        if (qualAlign > best)
+                            best = qualAlign;
+                    }
+                }
+                return best;
+            }
+            if (type->type == TYPESTRUCT) {
+                best = 4;
+                for (member = TYPE_STRUCT(type)->members; member; member = member->next) {
+                    ivarAlign = CMach_GetPPCTypeAlign(member->type, 0, flag2);
+                    if (ivarAlign > best)
+                        best = ivarAlign;
+                    if (flag2) {
+                        qualAlign = CMach_GetQUALalign(member->qual);
+                        if (qualAlign > best)
+                            best = qualAlign;
+                    }
+                }
+                return best;
+            }
+        }
+    }
+
+    return align;
+}
+
+static SInt16 CMach_GetQualifiedStructAlign(TypeStruct *tstruct, Boolean flag) {
+    StructMember *member;
+    SInt32 best;
+    SInt32 align;
+    Boolean isFirst;
+
+    // very close to matching but tstruct->stype gets cached when it should not be
+    if (tstruct->stype >= STRUCT_TYPE_4 && tstruct->stype <= STRUCT_TYPE_E) {
+        return 16;
+    } else {
+
+        switch (copts.align_mode) {
+            case AlignMode3_1Byte:
+            case AlignMode8:
+                return 1;
+            case AlignMode0_Mac68k:
+                return 2;
+            case AlignMode1_Mac68k4byte:
+                return (tstruct->size <= 2) ? 2 : 4;
+        }
+
+        if (tstruct->size <= 1)
+            return 1;
+        best = 1;
+        switch (copts.align_mode) {
+            default:
+#line 1026
+                CError_FATAL();
+            case AlignMode4_2Byte:
+            case AlignMode5_4Byte:
+            case AlignMode6_8Byte:
+            case AlignMode7_16Byte:
+                for (member = tstruct->members; member; member = member->next) {
+                    align = CMach_GetQualifiedTypeAlign(member->type, flag);
+                    if (align > best)
+                        best = align;
+                    if (flag) {
+                        align = CMach_GetQUALalign(member->qual);
+                        if (align > best)
+                            best = align;
+                    }
+                }
+                return best;
+            case AlignMode2_PPC:
+                if (copts.oldalignment) {
+                    for (member = tstruct->members; member; member = member->next) {
+                        align = CMach_GetQualifiedTypeAlign(member->type, flag);
+                        if (align > best)
+                            best = align;
+                        if (flag) {
+                            align = CMach_GetQUALalign(member->qual);
+                            if (align > best)
+                                best = align;
+                        }
+                    }
+                } else if (tstruct->stype == STRUCT_TYPE_UNION) {
+                    for (member = tstruct->members; member; member = member->next) {
+                        align = CMach_GetPPCTypeAlign(member->type, 1, flag);
+                        if (align > best)
+                            best = align;
+                        if (flag) {
+                            align = CMach_GetQUALalign(member->qual);
+                            if (align > best)
+                                best = align;
+                        }
+                    }
+                } else {
+                    isFirst = 1;
+                    for (member = tstruct->members; member; member = member->next) {
+                        align = CMach_GetPPCTypeAlign(member->type, isFirst || (best >= 8), flag);
+                        if (align > best)
+                            best = align;
+                        if (flag) {
+                            align = CMach_GetQUALalign(member->qual);
+                            if (align > best)
+                                best = align;
+                        }
+                        isFirst = 0;
+                    }
+                }
+                return best;
+        }
+    }
+}
+
+SInt16 CMach_GetStructAlign(TypeStruct *tstruct) {
+    return CMach_GetQualifiedStructAlign(tstruct, 1);
+}
+
+static SInt16 CMach_GetQualifiedClassAlign(TypeClass *tclass, Boolean flag) {
+    ClassList *base;
+    ObjMemberVar *ivar;
+    SInt32 best;
+    SInt32 align;
+    Boolean isFirst;
+
+    switch (copts.align_mode) {
+        case AlignMode3_1Byte:
+        case AlignMode8:
+            return 1;
+        case AlignMode0_Mac68k:
+            return 2;
+        case AlignMode1_Mac68k4byte:
+            return (tclass->size <= 2) ? 2 : 4;
+    }
+    if (tclass->size <= 1)
+        return 1;
+    best = 1;
+    switch (copts.align_mode) {
+        default:
+#line 1149
+            CError_FATAL();
+        case AlignMode4_2Byte:
+        case AlignMode5_4Byte:
+        case AlignMode6_8Byte:
+        case AlignMode7_16Byte:
+            for (base = tclass->bases; base; base = base->next) {
+                if ((align = base->base->align) > best)
+                    best = align;
+            }
+            for (ivar = tclass->ivars; ivar; ivar = ivar->next) {
+                align = CMach_GetMemberAlignment(ivar->type, flag ? CMach_GetQUALalign(ivar->qual) : 0, flag);
+                if (align > best)
+                    best = align;
+            }
+            return best;
+        case AlignMode2_PPC:
+            best = 1;
+            if (copts.oldalignment) {
+                for (base = tclass->bases; base; base = base->next) {
+                    if ((align = base->base->align) > best)
+                        best = align;
+                }
+                for (ivar = tclass->ivars; ivar; ivar = ivar->next) {
+                    align = CMach_GetMemberAlignment(ivar->type, flag ? CMach_GetQUALalign(ivar->qual) : 0, flag);
+                    if (align > best)
+                        best = align;
+                }
+            } else {
+                isFirst = 1;
+                for (base = tclass->bases; base; base = base->next) {
+                    if ((align = base->base->align) > best)
+                        best = align;
+                    isFirst = 0;
+                }
+                if (tclass->mode == 1) {
+                    for (ivar = tclass->ivars; ivar; ivar = ivar->next) {
+                        align = CMach_GetPPCTypeAlign(ivar->type, 1, flag);
+                        if (align > best)
+                            best = align;
+                        if (flag) {
+                            align = CMach_GetQUALalign(ivar->qual);
+                            if (align > best)
+                                best = align;
+                        }
+                    }
+                } else {
+                    for (ivar = tclass->ivars; ivar; ivar = ivar->next) {
+                        if (ivar->offset && align != 8)
+                            isFirst = 0;
+                        align = CMach_GetPPCTypeAlign(ivar->type, isFirst || (best >= 8), flag);
+                        if (align > best)
+                            best = align;
+                        if (flag) {
+                            align = CMach_GetQUALalign(ivar->qual);
+                            if (align > best)
+                                best = align;
+                        }
+                    }
+                }
+            }
+            return best;
+    }
+}
+
+SInt16 CMach_GetClassAlign(TypeClass *tclass) {
+    return CMach_GetQualifiedClassAlign(tclass, 1);
+}
+
+static SInt16 CMach_GetWinTypeAlign(Type *type) {
+    int packoffs = copts.align_mode - 3;
+    SInt32 align = cmach_packsize[packoffs];
+    if (type->size < align)
+        align = type->size;
+    return align;
+}
+
+static SInt16 CMach_GetWinMinimizeAlign(SInt16 align) {
+    int packoffs = copts.align_mode - 3;
+    SInt16 minimum = cmach_packsize[packoffs];
+    if (minimum < align)
+        align = minimum;
+    return align;
+}
+
+static SInt16 CMach_GetQualifiedTypeAlign(Type *type, Boolean flag) {
+    Boolean r31;
+    SInt16 align;
+
+    if (type->type == TYPESTRUCT && TYPE_STRUCT(type)->stype >= STRUCT_TYPE_4 && TYPE_STRUCT(type)->stype <= STRUCT_TYPE_E)
+        return 16;
+
+    switch (copts.align_mode) {
+        case AlignMode3_1Byte:
+        case AlignMode8:
+            return 1;
+        case AlignMode4_2Byte:
+        case AlignMode5_4Byte:
+        case AlignMode6_8Byte:
+        case AlignMode7_16Byte:
+            r31 = 1;
+            break;
+        default:
+            r31 = 0;
+            break;
+    }
+
+restart:
+    switch (type->type) {
+        case TYPEVOID:
+            return 0;
+        case TYPEFUNC:
+            return 0;
+        case TYPEENUM:
+            type = TYPE_ENUM(type)->enumtype;
+        case TYPEINT:
+            if (r31)
+                return CMach_GetWinTypeAlign(type);
+            if (type->size == 1)
+                return 1;
+            if (copts.oldalignment && type->size == 8)
+                return 8;
+            if (copts.align_mode != AlignMode0_Mac68k && type->size >= 4)
+                return 4;
+            return 2;
+        case TYPEFLOAT:
+            if (r31)
+                return CMach_GetWinTypeAlign(type);
+            switch (copts.align_mode) {
+                case AlignMode0_Mac68k:
+                    return 2;
+                case AlignMode1_Mac68k4byte:
+                    return 4;
+                case AlignMode2_PPC:
+                    if (copts.oldalignment && type->size > 4)
+                        return 8;
+                    return 4;
+                default:
+#line 1346
+                    CError_FATAL();
+            }
+        case TYPEMEMBERPOINTER:
+        case TYPEPOINTER:
+            if (r31)
+                return CMach_GetWinTypeAlign(type);
+            if (copts.align_mode == AlignMode0_Mac68k)
+                return 2;
+            else
+                return 4;
+        case TYPEARRAY:
+            if (copts.align_array_members) {
+                if (r31)
+                    return CMach_GetWinTypeAlign(type);
+                if (type->size == 1)
+                    return 1;
+                if (copts.align_mode == AlignMode0_Mac68k || type->size <= 2)
+                    return 2;
+                if (copts.align_mode == AlignMode1_Mac68k4byte || type->size < 8)
+                    return 4;
+                align = CMach_GetQualifiedTypeAlign(TYPE_POINTER(type)->target, flag);
+                if (align > 4)
+                    return align;
+                else
+                    return 4;
+            } else {
+                type = TYPE_POINTER(type)->target;
+                goto restart;
+            }
+        case TYPESTRUCT:
+            if (flag)
+                align = TYPE_STRUCT(type)->align;
+            else
+                align = CMach_GetQualifiedStructAlign(TYPE_STRUCT(type), flag);
+            if (r31)
+                return CMach_GetWinMinimizeAlign(align);
+            else
+                return align;
+        case TYPECLASS:
+            if (flag)
+                align = TYPE_CLASS(type)->align;
+            else
+                align = CMach_GetQualifiedClassAlign(TYPE_CLASS(type), flag);
+            if (r31)
+                return CMach_GetWinMinimizeAlign(align);
+            else
+                return align;
+        case TYPEBITFIELD:
+            type = TYPE_BITFIELD(type)->bitfieldtype;
+            goto restart;
+        case TYPETEMPLATE:
+            return 1;
+        default:
+#line 1392
+            CError_FATAL();
+            return 0;
+    }
+}
+
+SInt16 CMach_GetTypeAlign(Type *type) {
+    return CMach_GetQualifiedTypeAlign(type, 1);
+}
+
+static SInt16 CMach_GetMemberAlignment(Type *type, SInt32 var, Boolean flag) {
+    SInt32 align;
+
+    align = CMach_GetQualifiedTypeAlign(type, flag);
+    if (align < 1)
+        align = 1;
+
+    if (type->type == TYPESTRUCT && TYPE_STRUCT(type)->stype >= STRUCT_TYPE_4 && TYPE_STRUCT(type)->stype <= STRUCT_TYPE_E && align < 16)
+        align = 16;
+
+    switch (copts.align_mode) {
+        case AlignMode8:
+            align = 1;
+            break;
+        case AlignMode0_Mac68k:
+            if (align > 2)
+                align = 2;
+            break;
+        case AlignMode1_Mac68k4byte:
+            if (align > 4)
+                align = 4;
+            break;
+        case AlignMode2_PPC:
+            if (!copts.oldalignment)
+                align = CMach_GetPPCTypeAlign(type, !cmach_structoffset || (cmach_structalign >= 8), flag);
+            if (var > align)
+                align = var;
+            break;
+    }
+
+    if (align > cmach_structalign)
+        cmach_structalign = align;
+    return align;
+}
+
+SInt16 CMach_MemberAlignValue(Type *type, SInt32 var) {
+    SInt16 align = CMach_GetMemberAlignment(type, 0, 1);
+    if (align <= 1)
+        return 0;
+
+    return (align - 1) & (align - (var & (align - 1)));
+}
+
+static SInt16 MemberAlignValue(Type *type, SInt32 var1, SInt32 var2) {
+    SInt16 align = CMach_GetMemberAlignment(type, var2, 1);
+    return (align - 1) & (align - (var1 & (align - 1)));
+}
+
+void CMach_StructLayoutInitOffset(SInt32 offset) {
+    cmach_structoffset = offset;
+    cmach_structalign = 4;
+    cmach_curbfsize = 0;
+}
+
+SInt32 CMach_StructLayoutGetCurSize() {
+    return cmach_structoffset;
+}
+
+SInt32 CMach_StructLayoutGetOffset(Type *type, UInt32 qual) {
+    SInt32 align;
+    SInt32 offset;
+
+    qual = CParser_GetTypeQualifiers(type, qual);
+
+    cmach_curbfsize = 0;
+    align = MemberAlignValue(type, cmach_structoffset, CMach_GetQUALalign(qual));
+    offset = cmach_structoffset + align;
+    cmach_structoffset = offset + type->size;
+    return offset;
+}
+
+SInt32 CMach_StructLayoutBitfield(TypeBitfield *tbitfield, UInt32 qual) {
+    SInt16 align;
+    SInt16 padding_at_start;
+    SInt16 basesize;
+    SInt16 basesize_bits;
+    SInt16 required_alignment;
+    SInt16 r4;
+
+    padding_at_start = 0;
+    required_alignment = 0;
+    align = CMach_GetQUALalign(qual);
+    if (align <= tbitfield->bitfieldtype->size)
+        align = 0;
+
+    switch (tbitfield->bitfieldtype->size) {
+        case 1:
+            basesize = 1;
+            basesize_bits = 8;
+            required_alignment = 0;
+            break;
+        case 2:
+            basesize = 2;
+            basesize_bits = 16;
+            required_alignment = 2;
+            break;
+        case 4:
+            if (copts.align_mode != AlignMode0_Mac68k && copts.align_mode != AlignMode4_2Byte)
+                required_alignment = 4;
+            else
+                required_alignment = 2;
+            basesize = 4;
+            basesize_bits = 32;
+            break;
+        default:
+#line 1620
+            CError_FATAL();
+    }
+
+    switch (copts.align_mode) {
+        case AlignMode3_1Byte:
+        case AlignMode8:
+            required_alignment = 0;
+            break;
+    }
+
+    r4 = required_alignment;
+    if (align > required_alignment)
+        r4 = align;
+    if (r4 && (cmach_structoffset & (r4 - 1)))
+        padding_at_start = r4 - (cmach_structoffset & (r4 - 1));
+
+    if (!cmach_curbfsize) {
+        cmach_structoffset += padding_at_start;
+        if (!tbitfield->unkB)
+            return cmach_structoffset;
+        cmach_curbfsize = tbitfield->unkB;
+        cmach_curbfbasesize = basesize;
+        cmach_curbfoffset = cmach_structoffset;
+        cmach_structoffset += basesize;
+        tbitfield->unkA = 0;
+        return cmach_curbfoffset;
+    } else {
+        if (!tbitfield->unkB || (cmach_curbfsize + tbitfield->unkB) > basesize_bits || cmach_curbfbasesize != basesize) {
+            cmach_structoffset += padding_at_start;
+            cmach_curbfsize = 0;
+            cmach_curbfbasesize = basesize;
+            if (!tbitfield->unkB)
+                return cmach_structoffset;
+            cmach_curbfoffset = cmach_structoffset;
+            cmach_structoffset += basesize;
+        }
+        tbitfield->unkA = cmach_curbfsize;
+        cmach_curbfsize += tbitfield->unkB;
+        return cmach_curbfoffset;
+    }
+}
+
+static Boolean CMach_IsTrivialClass(TypeClass *tclass) {
+    return !CClass_Constructor(tclass);
+}
+
+UInt8 CMach_GetFunctionResultClass(TypeFunc *tfunc) {
+    switch (tfunc->functype->type) {
+        case TYPESTRUCT:
+            if (tfunc->functype->type == TYPESTRUCT && TYPE_STRUCT(tfunc->functype)->stype >= STRUCT_TYPE_4 && TYPE_STRUCT(tfunc->functype)->stype <= STRUCT_TYPE_E)
+                return 0;
+        case TYPECLASS:
+        case TYPEMEMBERPOINTER:
+            return CMach_PassResultInHiddenArg(tfunc->functype) ? 1 : 0;
+        default:
+            return 0;
+    }
+}
+
+Boolean CMach_PassResultInHiddenArg(Type *type) {
+    switch (type->type) {
+        case TYPESTRUCT:
+            if (TYPE_STRUCT(type)->stype >= STRUCT_TYPE_4 && TYPE_STRUCT(type)->stype <= STRUCT_TYPE_E)
+                return 0;
+            else
+                return 1;
+        case TYPECLASS:
+            return 1;
+        case TYPEMEMBERPOINTER:
+            return (type->size == 4) ? 0 : 1;
+        default:
+            return 0;
+    }
+}
+
+const char *CMach_GetCPU() {
+    switch (copts.cpu) {
+        case CPU_PPC401: return "__PPC401__";
+        case CPU_PPC403: return "__PPC403__";
+        case CPU_PPC505: return "__PPC505__";
+        case CPU_PPC509: return "__PPC509__";
+        case CPU_PPC555: return "__PPC555__";
+        case CPU_PPC556: return "__PPC556__";
+        case CPU_PPC565: return "__PPC565__";
+        case CPU_PPC601: return "__PPC601__";
+        case CPU_PPC602: return "__PPC602__";
+        case CPU_PPC603: return "__PPC603__";
+        case CPU_PPC603e: return "__PPC603e__";
+        case CPU_PPC604: return "__PPC604__";
+        case CPU_PPC604e: return "__PPC604e__";
+        case CPU_PPC740: return "__PPC740__";
+        case CPU_PPC750: return "__PPC750__";
+        case CPU_PPC801: return "__PPC801__";
+        case CPU_PPC821: return "__PPC821__";
+        case CPU_PPC823: return "__PPC823__";
+        case CPU_PPC850: return "__PPC850__";
+        case CPU_PPC860: return "__PPC860__";
+        case CPU_PPC7400: return "__PPC7400__";
+        case CPU_PPC7450: return "__PPC7450__";
+        case CPU_PPC8240: return "__PPC8240__";
+        case CPU_PPC8260: return "__PPC8260__";
+        case CPU_PPCGEKKO: return "__PPCGEKKO__";
+        case CPU_PPCELF: return "__PPCELF__";
+        default: return NULL;
+    }
+}
+
+Boolean CMach_FloatIsPowerOf2(Float flt) {
+    return (flt.value == 2.0) ||
+            (flt.value == 4.0) ||
+            (flt.value == 8.0) ||
+            (flt.value == 16.0) ||
+            (flt.value == 32.0) ||
+            (flt.value == 64.0) ||
+            (flt.value == 128.0) ||
+            (flt.value == 256.0) ||
+            (flt.value == 512.0) ||
+            (flt.value == 1024.0);
+}
+
+Float CMach_FloatReciprocal(Float flt) {
+    flt.value = 1.0 / flt.value;
+    return flt;
+}
+
+SInt32 CMach_RoundedSizeOf(Object *object) {
+    SInt32 size = object->type->size;
+    SInt32 align = CMach_GetTypeAlign(object->type) - 1;
+    return (size + align) & ~align;
+}
+
+void CMach_ReInitRuntimeObjects() {
+    HashNameNode *e0 = GetHashNameNodeExport("[0]");
+    HashNameNode *e1 = GetHashNameNodeExport("[1]");
+    HashNameNode *e2 = GetHashNameNodeExport("[2]");
+    HashNameNode *e3 = GetHashNameNodeExport("[3]");
+    HashNameNode *e4 = GetHashNameNodeExport("[4]");
+    HashNameNode *e5 = GetHashNameNodeExport("[5]");
+    HashNameNode *e6 = GetHashNameNodeExport("[6]");
+    HashNameNode *e7 = GetHashNameNodeExport("[7]");
+    HashNameNode *e8 = GetHashNameNodeExport("[8]");
+    HashNameNode *e9 = GetHashNameNodeExport("[9]");
+    HashNameNode *e10 = GetHashNameNodeExport("[10]");
+    HashNameNode *e11 = GetHashNameNodeExport("[11]");
+    HashNameNode *e12 = GetHashNameNodeExport("[12]");
+    HashNameNode *e13 = GetHashNameNodeExport("[13]");
+    HashNameNode *e14 = GetHashNameNodeExport("[14]");
+    HashNameNode *e15 = GetHashNameNodeExport("[15]");
+    HashNameNode *vuc = GetHashNameNodeExport("vector unsigned char");
+    HashNameNode *vus = GetHashNameNodeExport("vector unsigned short");
+    HashNameNode *vui = GetHashNameNodeExport("vector unsigned int");
+    HashNameNode *vsc = GetHashNameNodeExport("vector signed char");
+    HashNameNode *vss = GetHashNameNodeExport("vector signed short");
+    HashNameNode *vsi = GetHashNameNodeExport("vector signed int");
+    HashNameNode *vbc = GetHashNameNodeExport("vector bool char");
+    HashNameNode *vbs = GetHashNameNodeExport("vector bool short");
+    HashNameNode *vbi = GetHashNameNodeExport("vector bool int");
+    HashNameNode *vf = GetHashNameNodeExport("vector float");
+    HashNameNode *vp = GetHashNameNodeExport("vector pixel");
+
+    stvectorunsignedchar.name = vuc;
+    stvectorunsignedshort.name = vus;
+    stvectorunsignedlong.name = vui;
+    stvectorsignedchar.name = vsc;
+    stvectorsignedshort.name = vss;
+    stvectorsignedlong.name = vsi;
+    stvectorboolchar.name = vbc;
+    stvectorboolshort.name = vbs;
+    stvectorboollong.name = vbi;
+    stvectorfloat.name = vf;
+    stvectorpixel.name = vp;
+
+    stVUC_unsignedchar0.name = e0;
+    stVUC_unsignedchar1.name = e1;
+    stVUC_unsignedchar2.name = e2;
+    stVUC_unsignedchar3.name = e3;
+    stVUC_unsignedchar4.name = e4;
+    stVUC_unsignedchar5.name = e5;
+    stVUC_unsignedchar6.name = e6;
+    stVUC_unsignedchar7.name = e7;
+    stVUC_unsignedchar8.name = e8;
+    stVUC_unsignedchar9.name = e9;
+    stVUC_unsignedchar10.name = e10;
+    stVUC_unsignedchar11.name = e11;
+    stVUC_unsignedchar12.name = e12;
+    stVUC_unsignedchar13.name = e13;
+    stVUC_unsignedchar14.name = e14;
+    stVUC_unsignedchar15.name = e15;
+    stVSC_signedchar0.name = e0;
+    stVSC_signedchar1.name = e1;
+    stVSC_signedchar2.name = e2;
+    stVSC_signedchar3.name = e3;
+    stVSC_signedchar4.name = e4;
+    stVSC_signedchar5.name = e5;
+    stVSC_signedchar6.name = e6;
+    stVSC_signedchar7.name = e7;
+    stVSC_signedchar8.name = e8;
+    stVSC_signedchar9.name = e9;
+    stVSC_signedchar10.name = e10;
+    stVSC_signedchar11.name = e11;
+    stVSC_signedchar12.name = e12;
+    stVSC_signedchar13.name = e13;
+    stVSC_signedchar14.name = e14;
+    stVSC_signedchar15.name = e15;
+
+    stVUS_unsignedshort0.name = e0;
+    stVUS_unsignedshort1.name = e1;
+    stVUS_unsignedshort2.name = e2;
+    stVUS_unsignedshort3.name = e3;
+    stVUS_unsignedshort4.name = e4;
+    stVUS_unsignedshort5.name = e5;
+    stVUS_unsignedshort6.name = e6;
+    stVUS_unsignedshort7.name = e7;
+    stVSS_signedshort0.name = e0;
+    stVSS_signedshort1.name = e1;
+    stVSS_signedshort2.name = e2;
+    stVSS_signedshort3.name = e3;
+    stVSS_signedshort4.name = e4;
+    stVSS_signedshort5.name = e5;
+    stVSS_signedshort6.name = e6;
+    stVSS_signedshort7.name = e7;
+
+    stVUL_unsignedlong0.name = e0;
+    stVUL_unsignedlong1.name = e1;
+    stVUL_unsignedlong2.name = e2;
+    stVUL_unsignedlong3.name = e3;
+    stVSL_signedlong0.name = e0;
+    stVSL_signedlong1.name = e1;
+    stVSL_signedlong2.name = e2;
+    stVSL_signedlong3.name = e3;
+
+    stVF_float0.name = e0;
+    stVF_float1.name = e1;
+    stVF_float2.name = e2;
+    stVF_float3.name = e3;
+}