Ejemplo n.º 1
0
        /// <summary>
        /// Compiles a type.
        /// </summary>
        /// <param name="type">The type.</param>
        public void Compile(TypeDefinition type)
        {
            TypeKind typeKind = getTypeKind(type);

            Logger.LogVerbose(typeKind.GetColor(), "Compiling type {0}", type.FullName);

            // Enums can be fully generated during the declaration pass. Nothing to do.
            if (typeKind == TypeKind.Enum)
            {
                return;
            }

            // Add interface type to lookup?
            if (typeKind == TypeKind.Interface)
            {
                mLookup.AddInterface(type);
            }

            // VTable.
            VTable vtable    = null;
            bool   hasVTable = ((typeKind == TypeKind.Interface) || (typeKind == TypeKind.Class && mCompiler.Lookup.NeedsVirtualCall(type)));

            if (hasVTable)
            {
                vtable = new VTable(mCompiler, type);
                mLookup.AddVTable(vtable);
                vtable.Create();
                vtable.Compile();
            }

            // Create struct for this type.
            TypeRef             data       = mLookup.GetTypeRef(type);
            List <TypeRef>      structData = new List <TypeRef>();
            List <IStructEntry> fields     = mLookup.GetStructLayout(type);

            // Fields.
            ulong          fieldTotalSize = 0;
            TypeDefinition currentType    = type;

            foreach (IStructEntry entry in fields)
            {
                // VTable for a class?
                if (entry.EntryType == StructEntryType.ClassVTable)
                {
                    // Only if there are virtual calls on this type.
                    if (hasVTable)
                    {
                        VTableEntry castedEntry = (VTableEntry)entry;
                        structData.Add(LLVM.PointerType(vtable.GetEntry(castedEntry.Type).Item1, 0));
                    }
                }
                // Entry that points to a table of VTables for interfaces
                else if (entry.EntryType == StructEntryType.InterfaceVTablesTable)
                {
                    structData.Add(TypeHelper.VoidPtr);
                }
                // Field entry
                else /*if(entry.EntryType == StructEntryType.Field)*/
                {
                    FieldDefinition field     = ((StructFieldEntry)entry).Field;
                    TypeRef         fieldType = TypeHelper.GetTypeRefFromType(field.FieldType);
                    currentType = field.DeclaringType;

                    // Static field.
                    if (field.IsStatic)
                    {
                        // Only add it if we don't have it already (is possible when inheriting classes).
                        if (!mLookup.HasStaticField(field))
                        {
                            ValueRef val = LLVM.AddGlobal(mCompiler.Module, fieldType, NameHelper.CreateFieldName(field.FullName));

                            // Note: the initializer may be changed later if the compiler sees that it can be constant.
                            LLVM.SetInitializer(val, LLVM.ConstNull(fieldType));
                            mLookup.AddStaticField(field, val);
                        }
                    }
                    // Field for type instance.
                    else
                    {
                        structData.Add(fieldType);
                        fieldTotalSize += LLVM.SizeOfTypeInBits(mCompiler.TargetData, fieldType) / 8;
                    }
                }
            }

            // Packing?
            bool packed = (type.PackingSize != -1);

            if (type.PackingSize != 1 && type.PackingSize != -1 && type.PackingSize != 0)
            {
                throw new NotImplementedException("The packing size " + type.PackingSize + " is not implemented");
            }

            // Fixed size?
            if (type.ClassSize > 0 && (int)fieldTotalSize < type.ClassSize)
            {
                if (typeKind != TypeKind.Struct)
                {
                    throw new InvalidOperationException("Fixed size not on a struct?!");
                }

                // Note: we treat char as 8-bit. So we need to check if we're dealing with chars.
                int classSize = type.ClassSize;
                if (type.Fields.Count == 1 && type.Fields[0].FieldType.FullName == "System.Char")
                {
                    classSize /= 2;
                }

                // Add bytes until the needed size is reached.
                int needed = classSize - (int)fieldTotalSize;
                for (int i = 0; i < needed; i++)
                {
                    structData.Add(TypeHelper.Int8);
                }
            }

            // Set struct data.
            LLVM.StructSetBody(data, structData.ToArray(), packed);

            // For classes, generate the "newobj" method.
            if (typeKind == TypeKind.Class)
            {
                ValueRef newobjFunc = createNewobjMethod(type);
                mCompiler.Lookup.AddNewobjMethod(type, newobjFunc);
            }
        }