target/arm: Set instance_align on CPUARM TypeInfo

Fix alignment of CPUARMState.vfp.zregs.

Backports d03087bda4ba17076b430fd2af083020d7c5112a

qemu/accel.c

@@ -48,25 +48,20 @@ static int tcg_init(MachineState *ms)
 }
 
 static const TypeInfo accel_type = {
-    TYPE_ACCEL,
+    .name = TYPE_ACCEL,
-    TYPE_OBJECT,
+    .parent = TYPE_OBJECT,
-    sizeof(AccelClass),
+    .class_size = sizeof(AccelClass),
-    sizeof(AccelState),
+    .instance_size = sizeof(AccelState),
 };
 
 #define TYPE_TCG_ACCEL ACCEL_CLASS_NAME("tcg")
 
 static const TypeInfo tcg_accel_type = {
-    TYPE_TCG_ACCEL,
+    .name = TYPE_TCG_ACCEL,
-    TYPE_ACCEL,
+    .parent = TYPE_ACCEL,
-    0,
+    .class_size = 0,
-    0,
+    .instance_size = 0,
-    NULL,
+    .class_init = tcg_accel_class_init,
-    NULL,
-    NULL,
-    NULL,
-    NULL,
-    tcg_accel_class_init,
 };
 
 

qemu/hw/arm/virt.c

@@ -142,20 +142,14 @@ static void virt_class_init(struct uc_struct *uc, ObjectClass *oc, void *data)
 }
 
 static const TypeInfo machvirt_info = {
-    TYPE_VIRT_MACHINE,
+    .name = TYPE_VIRT_MACHINE,
-    TYPE_MACHINE,
+    .parent = TYPE_MACHINE,
 
-    sizeof(VirtMachineClass),
+    .class_size = sizeof(VirtMachineClass),
-    sizeof(VirtMachineState),
+    .instance_size = sizeof(VirtMachineState),
-    NULL,
 
-    virt_instance_init,
+    .instance_init = virt_instance_init,
-    NULL,
+    .class_init = virt_class_init,
-    NULL,
-
-    NULL,
-
-    virt_class_init,
 };
 
 void machvirt_machine_init(struct uc_struct *uc)

qemu/hw/core/machine.c

@@ -42,24 +42,19 @@ static void machine_finalize(struct uc_struct *uc, Object *obj, void *opaque)
 }
 
 static const TypeInfo machine_info = {
-    TYPE_MACHINE,
+    .name = TYPE_MACHINE,
-    TYPE_OBJECT,
+    .parent = TYPE_OBJECT,
 
-    sizeof(MachineClass),
+    .class_size = sizeof(MachineClass),
-    sizeof(MachineState),
+    .instance_size = sizeof(MachineState),
-    NULL,
 
-    machine_initfn,
+    .instance_init = machine_initfn,
-    NULL,
+    .instance_finalize = machine_finalize,
-    machine_finalize,
 
-    NULL,
+    .class_base_init = machine_class_base_init,
+    .class_finalize = machine_class_finalize,
 
-    NULL,
+    .abstract = true,
-    machine_class_base_init,
-    machine_class_finalize,
-
-    true,
 };
 
 void machine_register_types(struct uc_struct *uc)

qemu/hw/core/qdev.c

@@ -290,24 +290,20 @@ Object *qdev_get_machine(struct uc_struct *uc)
 }
 
 static const TypeInfo device_type_info = {
-    TYPE_DEVICE,
+    .name = TYPE_DEVICE,
-    TYPE_OBJECT,
+    .parent = TYPE_OBJECT,
 
-    sizeof(DeviceClass),
+    .class_size = sizeof(DeviceClass),
-    sizeof(DeviceState),
+    .instance_size = sizeof(DeviceState),
-    NULL,
 
-    device_initfn,
+    .instance_init = device_initfn,
-    device_post_init,
+    .instance_post_init = device_post_init,
-    device_finalize,
+    .instance_finalize = device_finalize,
 
-    NULL,
+    .class_init = device_class_init,
+    .class_base_init = device_class_base_init,
 
-    device_class_init,
+    .abstract = true,
-    device_class_base_init,
-    NULL,
-
-    true,
 };
 
 static void qbus_initfn(struct uc_struct *uc, Object *obj, void *opaque)
@@ -327,24 +323,17 @@ static void qbus_finalize(struct uc_struct *uc, Object *obj, void *opaque)
 }
 
 static const TypeInfo bus_info = {
-    TYPE_BUS,
+    .name = TYPE_BUS,
-    TYPE_OBJECT,
+    .parent = TYPE_OBJECT,
 
-    sizeof(BusClass),
+    .class_size = sizeof(BusClass),
-    sizeof(BusState),
+    .instance_size = sizeof(BusState),
-    NULL,
 
-    qbus_initfn,
+    .instance_init = qbus_initfn,
-    NULL,
+    .instance_finalize = qbus_finalize,
-    qbus_finalize,
 
-    NULL,
+    .class_init = bus_class_init,
-
+    .abstract = true,
-    bus_class_init,
-    NULL,
-    NULL,
-
-    true,
 };
 
 void qdev_register_types(struct uc_struct *uc)

qemu/hw/i386/pc.c

@@ -144,27 +144,16 @@ static void pc_machine_class_init(struct uc_struct *uc, ObjectClass *oc, void *d
 }
 
 static const TypeInfo pc_machine_info = {
-    TYPE_PC_MACHINE,
+    .name = TYPE_PC_MACHINE,
-    TYPE_MACHINE,
+    .parent = TYPE_MACHINE,
 
-    sizeof(PCMachineClass),
+    .class_size = sizeof(PCMachineClass),
-    sizeof(PCMachineState),
+    .instance_size = sizeof(PCMachineState),
-    NULL,
 
-    pc_machine_initfn,
+    .instance_init = pc_machine_initfn,
-    NULL,
+    .class_init = pc_machine_class_init,
-    NULL,
 
-    NULL,
+    .abstract = true,
-
-    pc_machine_class_init,
-    NULL,
-    NULL,
-
-    true,
-
-    NULL,
-    NULL,
 
     // should this be added somehow?
     //.interfaces = (InterfaceInfo[]) { { } },

qemu/hw/intc/apic.c

@@ -210,20 +210,13 @@ static void apic_class_init(struct uc_struct *uc, ObjectClass *klass, void *data
 }
 
 static const TypeInfo apic_info = {
-    "apic",
+    .name = "apic",
-    TYPE_APIC_COMMON,
+    .parent = TYPE_APIC_COMMON,
 
-    0,
+    .class_size = 0,
-    sizeof(APICCommonState),
+    .instance_size = sizeof(APICCommonState),
-    NULL,
 
-    NULL,
+    .class_init = apic_class_init,
-    NULL,
-    NULL,
-
-    NULL,
-
-    apic_class_init,
 };
 
 void apic_register_types(struct uc_struct *uc)

qemu/hw/intc/apic_common.c

@@ -242,28 +242,18 @@ static void apic_common_class_init(struct uc_struct *uc, ObjectClass *klass, voi
      * x86_cpu_apic_create()
      */
     dc->cannot_instantiate_with_device_add_yet = true;
-    //printf("... init apic common class\n");
 }
 
 static const TypeInfo apic_common_type = {
-    TYPE_APIC_COMMON,
+    .name = TYPE_APIC_COMMON,
-    TYPE_DEVICE,
+    .parent = TYPE_DEVICE,
 
-    sizeof(APICCommonClass),
+    .class_size = sizeof(APICCommonClass),
-    sizeof(APICCommonState),
+    .instance_size = sizeof(APICCommonState),
-    NULL,
 
-    NULL,
+    .class_init = apic_common_class_init,
-    NULL,
-    NULL,
 
-    NULL,
+    .abstract = true,
-
-    apic_common_class_init,
-    NULL,
-    NULL,
-
-    true,
 };
 
 void apic_common_register_types(struct uc_struct *uc)

qemu/hw/sparc64/sun4u.c

@@ -59,20 +59,9 @@ static void sun4u_class_init(struct uc_struct *uc, ObjectClass *oc, void *data)
 }
 
 static const TypeInfo sun4u_type = {
-    MACHINE_TYPE_NAME("sun4u"),
+    .name = MACHINE_TYPE_NAME("sun4u"),
-    TYPE_MACHINE,
+    .parent = TYPE_MACHINE,
-
+    .class_init = sun4u_class_init,
-    0,
-    0,
-    NULL,
-
-    NULL,
-    NULL,
-    NULL,
-
-    NULL,
-
-    sun4u_class_init,
 };
 
 void sun4u_machine_init(struct uc_struct *uc)

qemu/include/hw/boards.h

@@ -124,16 +124,9 @@ struct MachineState {
         machine_initfn(uc, mc); \
     } \
     static const TypeInfo machine_initfn##_typeinfo = { \
-        MACHINE_TYPE_NAME(namestr), \
+        .name = MACHINE_TYPE_NAME(namestr), \
-        TYPE_MACHINE, \
+        .parent = TYPE_MACHINE, \
-        0, \
+        .class_init = machine_initfn##_class_init, \
-        0, \
-        NULL, \
-        NULL, \
-        NULL, \
-        NULL, \
-        NULL, \
-        machine_initfn##_class_init, \
     }; \
     void machine_initfn##_register_types(struct uc_struct *uc) \
     { \

qemu/include/hw/i386/pc.h

@@ -58,16 +58,9 @@ void x86_cpu_register_types(struct uc_struct *uc);
         mc->arch = UC_ARCH_X86; \
     } \
     static const TypeInfo pc_machine_type_##suffix = { \
-        namestr TYPE_MACHINE_SUFFIX, \
+        .name = namestr TYPE_MACHINE_SUFFIX, \
-        TYPE_PC_MACHINE, \
+        .parent = TYPE_PC_MACHINE, \
-        0, \
+        .class_init = pc_machine_##suffix##_class_init, \
-        0, \
-        NULL, \
-        NULL, \
-        NULL, \
-        NULL, \
-        NULL, \
-        pc_machine_##suffix##_class_init, \
     }; \
     void pc_machine_init_##suffix(struct uc_struct *uc); \
     void pc_machine_init_##suffix(struct uc_struct *uc) \

qemu/memory.c

@@ -2029,16 +2029,14 @@ struct MemoryRegionList {
 typedef QTAILQ_HEAD(queue, MemoryRegionList) MemoryRegionListHead;
 
 static const TypeInfo memory_region_info = {
-    TYPE_MEMORY_REGION,
+    .name = TYPE_MEMORY_REGION,
-    TYPE_OBJECT,
+    .parent = TYPE_OBJECT,
 
-    0,
+    .class_size = 0,
-    sizeof(MemoryRegion),
+    .instance_size = sizeof(MemoryRegion),
-    NULL,
 
-    memory_region_initfn,
+    .instance_init = memory_region_initfn,
-    NULL,
+    .instance_finalize = memory_region_finalize,
-    memory_region_finalize,
 };
 
 void memory_register_types(struct uc_struct *uc)

qemu/qom/cpu.c

@@ -308,24 +308,18 @@ static void cpu_class_init(struct uc_struct *uc, ObjectClass *klass, void *data)
 }
 
 static const TypeInfo cpu_type_info = {
-    TYPE_CPU,
+    .name = TYPE_CPU,
-    TYPE_DEVICE,
+    .parent = TYPE_DEVICE,
 
-    sizeof(CPUClass),
+    .class_size = sizeof(CPUClass),
-    sizeof(CPUState),
+    .instance_size = sizeof(CPUState),
-    NULL,
 
-    cpu_common_initfn,
+    .instance_init = cpu_common_initfn,
-    NULL,
+    .instance_finalize = cpu_common_finalize,
-    cpu_common_finalize,
 
-    NULL,
+    .class_init = cpu_class_init,
 
-    cpu_class_init,
+    .abstract = true,
-    NULL,
-    NULL,
-
-    true,
 };
 
 void cpu_register_types(struct uc_struct *uc)

qemu/qom/object.c

@@ -2012,45 +2012,18 @@ static void object_class_init(struct uc_struct *uc, ObjectClass *klass, void *op
 void register_types_object(struct uc_struct *uc)
 {
     static TypeInfo interface_info = {
-        TYPE_INTERFACE,	// name
+        .name = TYPE_INTERFACE,
-        NULL,
+        .class_size = sizeof(InterfaceClass),
-
+        .instance_size = 0,
-        sizeof(InterfaceClass),	// class_size
+        .abstract = true,
-        0,
-        NULL,
-
-        NULL,
-        NULL,
-        NULL,
-
-        NULL,
-
-        NULL,
-        NULL,
-        NULL,
-
-        true,	// abstract
     };
 
     static TypeInfo object_info = {
-        TYPE_OBJECT,
+        .name = TYPE_OBJECT,
-        NULL,
+        .class_size = 0,
-
+        .instance_size = sizeof(Object),
-        0,
+        .class_init = object_class_init,
-        sizeof(Object),
+        .abstract = true,
-        NULL,
-
-        NULL,
-        NULL,
-        NULL,
-
-        NULL,
-
-        object_class_init,
-        NULL,
-        NULL,
-
-        true,
     };
 
     uc->type_interface = type_register_internal(uc, &interface_info);

qemu/target/arm/cpu.c

@@ -2074,6 +2074,7 @@ void arm_cpu_register(struct uc_struct *uc, const ARMCPUInfo *info)
     TypeInfo type_info = {
         .parent = TYPE_ARM_CPU,
         .instance_size = sizeof(ARMCPU),
+        .instance_align = __alignof__(ARMCPU),
         .instance_init = info->initfn,
         .class_size = sizeof(ARMCPUClass),
         .class_init = info->class_init,
@@ -2094,6 +2095,7 @@ void arm_cpu_register_types(void *opaque)
     arm_cpu_type_info.parent = TYPE_CPU,
     arm_cpu_type_info.instance_userdata = opaque,
     arm_cpu_type_info.instance_size = sizeof(ARMCPU),
+    arm_cpu_type_info.instance_align = __alignof__(ARMCPU),
     arm_cpu_type_info.instance_init = arm_cpu_initfn,
     arm_cpu_type_info.instance_post_init = arm_cpu_post_init,
     arm_cpu_type_info.instance_finalize = arm_cpu_finalizefn,