Example #1
0
    def setUp(self):
        super(TestReferencingToSelfDefinedType, self).setUp()
        name = type(self).__name__

        hdr = Header(name.lower() + ".h")
        m = Macro("M_OTHER_TYPE", text="int")
        hdr.add_type(m)

        ht = Header("macro_types.h")
        ht.add_type(Macro("M_TYPE", text="M_OTHER_TYPE"))
        ht.add_reference(m)

        hdr.add_global_variable(Type["M_TYPE"]("var"))

        hdr_content = """\
/* {path} */
#ifndef INCLUDE_{fname_upper}_H
#define INCLUDE_{fname_upper}_H

#define M_OTHER_TYPE int

#include "macro_types.h"

extern M_TYPE var;
#endif /* INCLUDE_{fname_upper}_H */
""".format(path=hdr.path, fname_upper=name.upper())

        self.files = [(hdr, hdr_content)]
Example #2
0
    def setUp(self):
        super(TestMacroType, self).setUp()
        name = type(self).__name__

        hdr = Header(name.lower() + ".h")
        hdr.add_type(Macro("QTAIL_ENTRY", args=["type"]))

        struct = Structure("StructA")
        struct.append_fields([
            Type["QTAIL_ENTRY"]("entry",
                                macro_initializer=Initializer({"type":
                                                               struct})),
            Pointer(struct)("next")
        ])
        hdr.add_type(struct)

        hdr_content = """\
/* {path} */
#ifndef INCLUDE_{fname_upper}_H
#define INCLUDE_{fname_upper}_H

#define QTAIL_ENTRY(type)

typedef struct StructA StructA;

struct StructA {{
    QTAIL_ENTRY(StructA) entry;
    StructA *next;
}};

#endif /* INCLUDE_{fname_upper}_H */
""".format(path=hdr.path, fname_upper=name.upper())

        self.files = [(hdr, hdr_content)]
Example #3
0
    def setUp(self):
        super(TestOpaqueCode, self).setUp()

        name = type(self).__name__

        hdr = Header(name.lower() + ".h", protection=False)

        test_var = Type["int"]("test_var")
        test_func = Function(name="test_func")

        opaque_top = OpaqueCode("""\
/* Generic comment above macros */
""",
                                weight=0)

        opaque_bottom = OpaqueCode("""
/* A comment at bottom of file */
""",
                                   weight=10)

        opaque_middle = OpaqueCode("""
/* How to use test_var and test_func. */

""",
                                   used_variables=[test_var],
                                   used_types=[test_func]
                                   # Default weight (5)
                                   )

        hdr.add_types([
            # Yields #define statement with weight 1
            Macro("TEST_MACRO"),
            # Yields function declaration with weight 6
            Function(name="another_test_func"),
            opaque_middle,
            opaque_bottom,
            opaque_top
        ])

        hdr_content = """\
/* {path} */

/* Generic comment above macros */

#define TEST_MACRO

extern int test_var;
void test_func(void);

/* How to use test_var and test_func. */

void another_test_func(void);

/* A comment at bottom of file */
""".format(path=hdr.path)

        self.files = [(hdr, hdr_content)]
Example #4
0
    def gen_property_macros(self, source):
        for field in self.state_fields:
            if not field.prop:
                continue
            if field.prop_macro_name is None:
                continue

            t = Macro(field.prop_macro_name, text = field.prop_name)
            source.add_type(t)
Example #5
0
    def fill_header(self):
        self.state_struct = self.gen_state()

        self.header.add_type(self.state_struct)

        self.type_name_macros = Macro(name=self.qtn.type_macro,
                                      text='"%s"' % self.qtn.for_id_name)

        self.header.add_type(self.type_name_macros)

        self.type_cast_macro = Macro(
            name=self.qtn.for_macros,
            args=["obj"],
            text="OBJECT_CHECK({Struct}, (obj), {TYPE_MACRO})".format(
                TYPE_MACRO=self.qtn.type_macro, Struct=self.struct_name))

        self.header.add_type(self.type_cast_macro)

        line_origins(
            [self.type_name_macros, self.type_cast_macro, self.state_struct])

        for mmioN in range(0, self.mmio_num):
            size_macro = Macro(name=self.gen_Ith_mmio_size_macro_name(mmioN),
                               text=self.gen_mmio_size(
                                   self.mmio.get(mmioN, None)))
            name_macro = Macro(
                name=self.get_Ith_mmio_name_macro_name(mmioN),
                text='%s "_%s"' %
                (self.qtn.type_macro, self.get_Ith_mmio_id_component(mmioN)))

            (self.header if MACROS_2_HEADER else self.source).add_types(
                [size_macro, name_macro])

            self.mmio_size_macros.append(size_macro)
            self.mmio_name_macros.append(name_macro)

        pio_def_size = 0x4
        pio_cur_addres = 0x1000

        for pioN in range(0, self.pio_num):
            size_macro = Macro(name=self.gen_Ith_pio_size_macro_name(pioN),
                               text="0x%X" % pio_def_size)
            address_macro = Macro(
                name=self.gen_Ith_pio_address_macro_name(pioN),
                text="0x%X" % pio_cur_addres)
            pio_cur_addres += pio_def_size

            self.header.add_types([size_macro, address_macro])

            self.pio_size_macros.append(size_macro)
            self.pio_address_macros.append(address_macro)

        if self.in_irq_num > 0:
            self.in_irq_macro = Macro(name=self.qtn.for_macros + "_IN_IRQ_NUM",
                                      text="%d" % self.in_irq_num)

            self.header.add_type(self.in_irq_macro)

        self.gen_property_macros(self.header)
Example #6
0
    def setUp(self):
        super(TestMacroType, self).setUp()
        name = type(self).__name__

        Header("entry_macro.h").add_type(Macro("QTAIL_ENTRY", args=["type"]))
        Header("struct_end.h").add_type(Macro("END_STRUCT"))
        Header("header_init.h").add_type(Macro("INIT_HEADER"))

        hdr = Header(name.lower() + ".h")
        struct = Structure("StructA")
        struct.append_fields([
            Type["QTAIL_ENTRY"]("entry",
                                macro_initializer=Initializer({"type":
                                                               struct})),
            Pointer(struct)("next"), Type["END_STRUCT"].gen_type()
        ])
        hdr.add_type(struct)

        hdr.add_type(Type["INIT_HEADER"].gen_type())

        hdr_content = """\
/* {path} */
#ifndef INCLUDE_{fname_upper}_H
#define INCLUDE_{fname_upper}_H

#include "entry_macro.h"
#include "header_init.h"
#include "struct_end.h"

typedef struct StructA StructA;

struct StructA {{
    QTAIL_ENTRY(StructA) entry;
    StructA *next;
    END_STRUCT
}};

INIT_HEADER
#endif /* INCLUDE_{fname_upper}_H */
""".format(path=hdr.path, fname_upper=name.upper())

        self.files = [(hdr, hdr_content)]
Example #7
0
    def generate_header(self):
        self.state_struct = self.gen_state()

        self.header.add_type(self.state_struct)

        self.type_name_macros = Macro(name=self.qtn.type_macro,
                                      text='"%s"' % self.qtn.for_id_name)

        self.header.add_type(self.type_name_macros)

        self.type_cast_macro = Macro(
            name=self.qtn.for_macros,
            args=["obj"],
            text="OBJECT_CHECK({Struct}, (obj), {TYPE_MACRO})".format(
                TYPE_MACRO=self.qtn.type_macro, Struct=self.struct_name))

        self.header.add_type(self.type_cast_macro)

        line_origins(
            [self.type_name_macros, self.type_cast_macro, self.state_struct])

        for mmioN in range(0, self.mmio_num):
            size_macro = Macro(name=self.gen_Ith_mmio_size_macro_name(mmioN),
                               text=self.gen_mmio_size(
                                   self.mmio.get(mmioN, None)))

            self.header.add_type(size_macro)
            self.mmio_size_macros.append(size_macro)

        pio_def_size = 0x4
        pio_cur_addres = 0x1000

        for pioN in range(0, self.pio_num):
            size_macro = Macro(name=self.gen_Ith_pio_size_macro_name(pioN),
                               text="0x%X" % pio_def_size)
            address_macro = Macro(
                name=self.gen_Ith_pio_address_macro_name(pioN),
                text="0x%X" % pio_cur_addres)
            pio_cur_addres += pio_def_size

            self.header.add_types([size_macro, address_macro])

            self.pio_size_macros.append(size_macro)
            self.pio_address_macros.append(address_macro)

        if self.in_irq_num > 0:
            self.in_irq_macro = Macro(name="%s_IN_IRQ_NUM" %
                                      self.qtn.for_macros,
                                      text="%d" % self.in_irq_num)

            self.header.add_type(self.in_irq_macro)

        self.gen_property_macros(self.header)

        # TODO: current value of inherit_references is dictated by Qemu coding
        # policy. Hence, version API must be used there.
        header_source = self.header.generate(inherit_references=True)

        return header_source
Example #8
0
    def generate_header(self):
        self.state_struct = self.gen_state()
        self.header.add_type(self.state_struct)

        self.type_name_macros = Macro(name=self.qtn.type_macro,
                                      text='"%s"' % self.qtn.for_id_name)
        self.header.add_type(self.type_name_macros)

        self.type_cast_macro = Macro(
            name=self.qtn.for_macros,
            args=["obj"],
            text="OBJECT_CHECK({Struct}, (obj), {TYPE_MACRO})".format(
                TYPE_MACRO=self.qtn.type_macro, Struct=self.struct_name))
        self.header.add_type(self.type_cast_macro)

        line_origins(
            [self.type_name_macros, self.type_cast_macro, self.state_struct])

        self.vendor_macro = self.vendor.find_macro()

        if self.subsystem_vendor and self.subsystem:
            self.subsystem_vendor_macro = self.subsystem_vendor.find_macro()
        else:
            self.subsystem_vendor_macro = None

        try:
            self.device_macro = self.device.find_macro()
        except TypeNotRegistered:
            # TODO: add device id macro to pci_ids.h
            self.header.add_type(
                Macro(name="PCI_DEVICE_ID_%s_%s" %
                      (self.vendor.name, self.device.name),
                      text=self.device.id))

            self.device_macro = self.device.find_macro()

        if self.subsystem_vendor and self.subsystem:
            try:
                self.subsystem_macro = self.subsystem.find_macro()
            except TypeNotRegistered:
                # TODO: add device id macro to pci_ids.h
                self.header.add_type(
                    Macro(name="PCI_DEVICE_ID_%s_%s" %
                          (self.subsystem_vendor.name, self.subsystem.name),
                          text=self.subsystem.id))

                self.subsystem_macro = self.subsystem.find_macro()
        else:
            self.subsystem_macro = None

        self.pci_class_macro = self.pci_class.find_macro()

        mem_bar_def_size = 0x100

        for barN in range(0, self.mem_bar_num):
            size_macro = Macro(name=self.gen_Ith_mem_bar_size_macro_name(barN),
                               text="0x%X" % mem_bar_def_size)

            self.mem_bar_size_macros.append(size_macro)
            self.header.add_type(size_macro)

        if self.msi_messages_num > 0:
            self.msi_cap_offset = Macro(name="%s_MSI_CAP_OFFSET" %
                                        self.qtn.for_macros,
                                        text="0x48")
            self.msi_vectors = Macro(name="%s_MSI_VECTORS" %
                                     self.qtn.for_macros,
                                     text="%u" % self.msi_messages_num)
            self.msi_64bit = Macro(name="%s_MSI_64BIT" % self.qtn.for_macros,
                                   text="1")
            self.msi_masking = Macro(name="%s_MSI_VECTOR_MASKING" %
                                     self.qtn.for_macros,
                                     text="1")

            self.msi_types = [
                self.msi_cap_offset, self.msi_vectors, self.msi_64bit,
                self.msi_masking
            ]

            line_origins(self.msi_types)

            self.header.add_types(self.msi_types)

        self.gen_property_macros(self.header)

        # TODO: current value of inherit_references is dictated by Qemu coding
        # policy. Hence, version API must be used there.
        return self.header.generate(inherit_references=True)
Example #9
0
class PCIExpressDeviceType(QOMDevice):
    __attribute_info__ = OrderedDict([
        # Note that multiple NIC generation is not implemented yet.
        ("nic_num", {
            "short": _("Network interface"),
            "input": bool
        }),
        ("vendor", {
            "short": _("Vendor"),
            "input": PCIId
        }),
        ("device", {
            "short": _("Device"),
            "input": PCIId
        }),
        ("pci_class", {
            "short": _("Class"),
            "input": PCIId
        }),
        ("subsys_vendor", {
            "short": _("Subsystem vendor"),
            "input": PCIId
        }),
        ("subsys", {
            "short": _("Subsystem"),
            "input": PCIId
        }),
        ("irq_num", {
            "short": _("IRQ pin quantity"),
            "input": int
        }),
        ("mem_bar_num", {
            "short": _("BAR quantity"),
            "input": int
        }),
        ("msi_messages_num", {
            "short": _("MSI message quantity"),
            "input": int
        }),
        ("revision", {
            "short": _("Revision"),
            "input": int
        })
    ])

    def __init__(self,
                 name,
                 directory,
                 vendor,
                 device,
                 pci_class,
                 irq_num=0,
                 mem_bar_num=0,
                 msi_messages_num=0,
                 revision=0,
                 subsys=None,
                 subsys_vendor=None,
                 bars=None,
                 **qomd_kw):
        super(PCIExpressDeviceType, self).__init__(name, directory, **qomd_kw)

        if get_vp("PCIE requires interface"):
            self.interfaces.add("INTERFACE_PCIE_DEVICE")
            # TODO: what about INTERFACE_CONVENTIONAL_PCI_DEVICE?

        self.irq_num = irq_num
        self.mem_bar_num = mem_bar_num
        self.msi_messages_num = msi_messages_num

        self.revision = revision

        self.vendor = vendor
        self.device = device
        self.pci_class = pci_class

        self.subsystem = subsys
        self.subsystem_vendor = subsys_vendor

        self.bars = {} if bars is None else dcp(bars)

        # Cast all PCI identifiers to PCIId
        for attr in ["vendor", "subsystem_vendor"]:
            val = getattr(self, attr)
            if (val is not None) and (not isinstance(val, PCIId)):
                try:
                    val = PCIId.db.get_vendor(name=val)
                except PCIVendorIdNetherExistsNorCreated:
                    val = PCIId.db.get_vendor(vid=val)
            setattr(self, attr, val)

        for attr, vendor in [("device", self.vendor),
                             ("subsystem", self.subsystem_vendor)]:
            val = getattr(self, attr)
            if (val is not None) and (not isinstance(val, PCIId)):
                if vendor is None:
                    raise Exception(
                        "Cannot get %s ID descriptor because of no \
corresponding vendor is given" % attr)
                try:
                    val = PCIId.db.get_device(name=val,
                                              vendor_name=vendor.name,
                                              vid=vendor.id)
                except Exception:
                    val = PCIId.db.get_device(did=val,
                                              vendor_name=vendor.name,
                                              vid=vendor.id)
            setattr(self, attr, val)

        val = getattr(self, "pci_class")
        # None is not allowed there
        if not isinstance(val, PCIId):
            try:
                val = PCIId.db.get_class(name=val)
            except:
                val = PCIId.db.get_class(cid=val)
        self.pci_class = val

        self.mem_bar_size_macros = []

        self.add_state_field_h("PCIDevice", "parent_obj")

        for irqN in range(0, self.irq_num):
            self.add_state_field_h("qemu_irq",
                                   self.get_Ith_irq_name(irqN),
                                   save=False)

        for barN in xrange(0, self.mem_bar_num):
            self.add_state_field_h("MemoryRegion",
                                   self.get_Ith_mem_bar_name(barN),
                                   save=False)

        self.timer_declare_fields()

        self.char_declare_fields()

        self.block_declare_fields()

        self.nic_declare_fields()

    def generate_header(self):
        self.state_struct = self.gen_state()
        self.header.add_type(self.state_struct)

        self.type_name_macros = Macro(name=self.qtn.type_macro,
                                      text='"%s"' % self.qtn.for_id_name)
        self.header.add_type(self.type_name_macros)

        self.type_cast_macro = Macro(
            name=self.qtn.for_macros,
            args=["obj"],
            text="OBJECT_CHECK({Struct}, (obj), {TYPE_MACRO})".format(
                TYPE_MACRO=self.qtn.type_macro, Struct=self.struct_name))
        self.header.add_type(self.type_cast_macro)

        line_origins(
            [self.type_name_macros, self.type_cast_macro, self.state_struct])

        self.vendor_macro = self.vendor.find_macro()

        if self.subsystem_vendor and self.subsystem:
            self.subsystem_vendor_macro = self.subsystem_vendor.find_macro()
        else:
            self.subsystem_vendor_macro = None

        try:
            self.device_macro = self.device.find_macro()
        except TypeNotRegistered:
            # TODO: add device id macro to pci_ids.h
            self.header.add_type(
                Macro(name="PCI_DEVICE_ID_%s_%s" %
                      (self.vendor.name, self.device.name),
                      text=self.device.id))

            self.device_macro = self.device.find_macro()

        if self.subsystem_vendor and self.subsystem:
            try:
                self.subsystem_macro = self.subsystem.find_macro()
            except TypeNotRegistered:
                # TODO: add device id macro to pci_ids.h
                self.header.add_type(
                    Macro(name="PCI_DEVICE_ID_%s_%s" %
                          (self.subsystem_vendor.name, self.subsystem.name),
                          text=self.subsystem.id))

                self.subsystem_macro = self.subsystem.find_macro()
        else:
            self.subsystem_macro = None

        self.pci_class_macro = self.pci_class.find_macro()

        mem_bar_def_size = 0x100

        for barN in range(0, self.mem_bar_num):
            size_macro = Macro(name=self.gen_Ith_mem_bar_size_macro_name(barN),
                               text="0x%X" % mem_bar_def_size)

            self.mem_bar_size_macros.append(size_macro)
            self.header.add_type(size_macro)

        if self.msi_messages_num > 0:
            self.msi_cap_offset = Macro(name="%s_MSI_CAP_OFFSET" %
                                        self.qtn.for_macros,
                                        text="0x48")
            self.msi_vectors = Macro(name="%s_MSI_VECTORS" %
                                     self.qtn.for_macros,
                                     text="%u" % self.msi_messages_num)
            self.msi_64bit = Macro(name="%s_MSI_64BIT" % self.qtn.for_macros,
                                   text="1")
            self.msi_masking = Macro(name="%s_MSI_VECTOR_MASKING" %
                                     self.qtn.for_macros,
                                     text="1")

            self.msi_types = [
                self.msi_cap_offset, self.msi_vectors, self.msi_64bit,
                self.msi_masking
            ]

            line_origins(self.msi_types)

            self.header.add_types(self.msi_types)

        self.gen_property_macros(self.header)

        # TODO: current value of inherit_references is dictated by Qemu coding
        # policy. Hence, version API must be used there.
        return self.header.generate(inherit_references=True)

    def generate_source(self):
        self.device_reset = Function(
            "%s_reset" % self.qtn.for_id_name,
            body="""\
    __attribute__((unused))@b{Struct}@b*s@b=@s{UPPER}(dev);
""".format(
                Struct=self.state_struct.name,
                UPPER=self.type_cast_macro.name,
            ),
            args=[Type.lookup("DeviceState").gen_var("dev", True)],
            static=True,
            used_types=[self.state_struct])
        self.source.add_type(self.device_reset)

        realize_code = ''
        realize_used_types = set()
        realize_used_globals = []
        s_is_used = False

        if self.mem_bar_num > 0:
            s_is_used = True
            realize_used_types.update([
                Type.lookup("sysbus_init_mmio"),
                Type.lookup("memory_region_init_io"),
                Type.lookup("Object")
            ])

        for barN in range(0, self.mem_bar_num):
            size_macro = self.mem_bar_size_macros[barN]
            realize_used_types.add(size_macro)

            component = self.get_Ith_mem_bar_id_component(barN)

            read_func = QOMType.gen_mmio_read(
                name=self.qtn.for_id_name + "_" + component + "_read",
                struct_name=self.state_struct.name,
                type_cast_macro=self.type_cast_macro.name,
                regs=self.bars.get(barN, None))

            write_func = QOMType.gen_mmio_write(
                name=self.qtn.for_id_name + "_" + component + "_write",
                struct_name=self.state_struct.name,
                type_cast_macro=self.type_cast_macro.name,
                regs=self.bars.get(barN, None))

            write_func.extra_references = {read_func}

            self.source.add_types([read_func, write_func])

            ops_init = Initializer(used_types=[read_func, write_func],
                                   code="""{{
    .read = {read},
    .write = {write}
}}""".format(read=read_func.name, write=write_func.name))

            ops = Type.lookup("MemoryRegionOps").gen_var(
                name=self.gen_Ith_mem_bar_ops_name(barN),
                pointer=False,
                initializer=ops_init,
                static=True)

            self.source.add_global_variable(ops)
            realize_used_globals.append(ops)

            realize_code += """
    memory_region_init_io(@a&s->{bar},@sOBJECT(dev),@s&{ops},@ss,@s{TYPE_MACRO},@s{size});
    pci_register_bar(@a&s->parent_obj,@s{barN},@sPCI_BASE_ADDRESS_SPACE_MEMORY,@s&s->{bar});
""".format(barN=barN,
            bar=self.get_Ith_mem_bar_name(barN),
            ops=self.gen_Ith_mem_bar_ops_name(barN),
            TYPE_MACRO=self.qtn.type_macro,
            size=size_macro.name)

        if self.msi_messages_num > 0:
            msi_init_type = Type.lookup("msi_init")
            s_is_used = True

            realize_code += """
    msi_init(dev,@s%s,@s%s,@s%s,@s%s%s);
""" % (self.msi_cap_offset.gen_usage_string(),
            self.msi_vectors.gen_usage_string(),
            self.msi_64bit.gen_usage_string(),
            self.msi_masking.gen_usage_string(),
            ",@serrp" if msi_init_type.args[-1].type \
                   == Pointer(Pointer(Type.lookup("Error"))) else ""
            )

            realize_used_types.update(self.msi_types)
            realize_used_types.add(msi_init_type)

        self.device_realize = self.gen_realize(
            "PCIDevice",
            code=realize_code,
            s_is_used=s_is_used,
            used_types=realize_used_types,
            used_globals=realize_used_globals)
        self.source.add_type(self.device_realize)

        code = ""
        used_types = set([self.state_struct])
        used_s = False

        if self.msi_messages_num > 0:
            code += """
    msi_uninit(dev);
"""
            used_types.add(Type.lookup("msi_uninit"))

        if self.nic_num > 0:
            code += "\n"
            used_s = True

            del_nic = Type.lookup("qemu_del_nic")
            used_types.add(del_nic)

            for nicN in xrange(self.nic_num):
                nic_name = self.nic_name(nicN)
                code += "    %s(s->%s);\n" % (del_nic.name, nic_name)

        if self.timer_num > 0:
            used_s = True
            code += "\n"
            used_types.update(
                [Type.lookup("timer_del"),
                 Type.lookup("timer_free")])

            for timerN in range(self.timer_num):
                code += """    timer_del(s->{timerN});
    timer_free(s->{timerN});
""".format(timerN=self.timer_name(timerN))

        self.device_exit = Function(
            name="%s_exit" % self.qtn.for_id_name,
            args=[Type.lookup("PCIDevice").gen_var("dev", pointer=True)],
            static=True,
            used_types=used_types,
            body="""\
    {unused}{Struct}@b*s@b=@s{UPPER}(dev);
{extra_code}\
""".format(unused="" if used_s else "__attribute__((unused))@b",
           Struct=self.state_struct.name,
           UPPER=self.type_cast_macro.name,
           extra_code=code))
        self.source.add_type(self.device_exit)

        self.vmstate = self.gen_vmstate_var(self.state_struct)

        self.source.add_global_variable(self.vmstate)

        self.properties = self.gen_properties_global(self.state_struct)

        self.source.add_global_variable(self.properties)

        self.vmstate.extra_references = {self.properties}

        self.class_init = Function(
            name="%s_class_init" % self.qtn.for_id_name,
            body="""\
    DeviceClass@b*dc@b=@sDEVICE_CLASS(oc);
    PCIDeviceClass@b*pc@b=@sPCI_DEVICE_CLASS(oc);

    pc->realize@b@b@b{pad}=@s{dev}_realize;
    dc->reset@b@b@b@b@b{pad}=@s{dev}_reset;
    pc->exit@b@b@b@b@b@b{pad}=@s{dev}_exit;
    pc->vendor_id@b{pad}=@s{vendor_macro};
    pc->device_id@b{pad}=@s{device_macro};
    pc->class_id@b@b{pad}=@s{pci_class_macro};{subsys_id}{subsys_vid}
    pc->revision@b@b{pad}=@s{revision};
    dc->vmsd@b@b@b@b@b@b{pad}=@s&vmstate_{dev};
    dc->props@b@b@b@b@b{pad}=@s{dev}_properties;
""".format(dev=self.qtn.for_id_name,
           revision=self.revision,
           vendor_macro=self.vendor_macro.name,
           device_macro=self.device_macro.name,
           pci_class_macro=self.pci_class_macro.name,
           subsys_id='' if self.subsystem_macro is None else ("""
    pc->subsystem_id@b@b@b@b@b@b@b@b=@s%s;""" % self.subsystem_macro.name),
           subsys_vid='' if self.subsystem_vendor_macro is None else ("""
    pc->subsystem_vendor_id@b=@s%s;""" % self.subsystem_vendor_macro.name),
           pad='@b@b@b@b@b@b@b@b@b@b' if self.subsystem_vendor_macro else ''),
            args=[
                Type.lookup("ObjectClass").gen_var("oc", True),
                Type.lookup("void").gen_var("opaque", True),
            ],
            static=True,
            used_types=[
                Type.lookup("DeviceClass"),
                Type.lookup("PCIDeviceClass"), self.device_realize,
                self.device_reset, self.device_exit, self.vendor_macro,
                self.device_macro, self.pci_class_macro
            ],
            used_globals=[self.vmstate, self.properties])
        self.source.add_type(self.class_init)

        instance_init_used_types = set()
        instance_init_code = ""
        s_is_used = False

        self.instance_init = self.gen_instance_init_fn(
            self.state_struct,
            code=instance_init_code,
            s_is_used=s_is_used,
            used_types=instance_init_used_types)
        self.source.add_type(self.instance_init)

        self.type_info = self.gen_type_info_var(self.state_struct,
                                                self.instance_init,
                                                self.class_init,
                                                parent_tn="TYPE_PCI_DEVICE")

        self.source.add_global_variable(self.type_info)

        self.register_types = self.gen_register_types_fn(self.type_info)

        self.source.add_type(self.register_types)

        type_init_usage_init = Initializer(
            code={"function": self.register_types})
        self.source.add_type(
            Type.lookup("type_init").gen_usage(type_init_usage_init))

        # order life cycle functions
        self.device_reset.extra_references = {self.device_realize}
        self.device_exit.extra_references = {self.device_reset}

        return self.source.generate()

    def get_Ith_mem_bar_id_component(self, i):
        return self.get_Ith_mem_bar_name(i)

    def gen_Ith_mem_bar_size_macro_name(self, i):
        UPPER = self.get_Ith_mem_bar_id_component(i).upper()
        return "%s_%s_SIZE" % (self.qtn.for_macros, UPPER)

    def gen_Ith_mem_bar_ops_name(self, i):
        return self.qtn.for_id_name + "_" \
            + self.get_Ith_mem_bar_id_component(i) + "_ops"

    def get_Ith_mem_bar_name(self, i):
        if self.mem_bar_num == 1:
            return "mem_bar"
        else:
            return "mem_bar_%u" % i

    def get_Ith_irq_name(self, i):
        if self.irq_num == 1:
            return "irq"
        else:
            return "irq_{}".format(i)
Example #10
0
def define_only_qemu_2_6_0_types():
    # According to Qemu inclusion policy, each source file must include
    # qemu/osdep.h. This could be met using different ways. For now add a
    # reference to a fake type inside osdep.h.
    # TODO: the tweak must be handled using version API.
    osdep_fake_type = Type("FAKE_TYPE_IN_QEMU_OSDEP")

    if not get_vp("tcg_enabled is macro"):
        Header.lookup("qemu-common.h").add_types(
            [Function("tcg_enabled", ret_type=Type.lookup("bool"))])

    Header.lookup("tcg.h").add_types([
        Type("TCGv_i32"),
        Type("TCGv_i64"),
        Type("TCGv_ptr"),
        Type("TCGv_env"),
        Type("TCGv"),
        Function("tcg_global_mem_new_i32"),
        Function("tcg_global_mem_new_i64"),
        Function("tcg_op_buf_full")
    ])

    Header.lookup("tcg-op.h").add_types([
        Function("tcg_gen_insn_start"),
        Function("tcg_gen_goto_tb"),
        Function("tcg_gen_exit_tb")
    ])

    Header.lookup("tcg-op.h").add_types([
        # HLTTemp is a fake type intended to mark
        # variables which are to be replaced by this tool
        # preprocessor (still in progress)
        # HLTTemp is then converted to some existing QEMU types
        Type("HLTTemp")
    ])

    Header.lookup("qemu/osdep.h").add_types([osdep_fake_type])

    Header.lookup("exec/hwaddr.h").add_types([Type("hwaddr", False)
                                              ]).add_reference(osdep_fake_type)

    Header.lookup("exec/cpu-defs.h").add_types([
        Type("target_ulong", False),
    ])

    Header.lookup("exec/cpu_ldst.h").add_types([
        Function("cpu_ldub_code", ret_type=Type.lookup("uint8_t")),
        Function("cpu_lduw_code", ret_type=Type.lookup("uint16_t")),
        Function("cpu_ldl_code", ret_type=Type.lookup("uint32_t")),
        Function("cpu_ldq_code", ret_type=Type.lookup("uint64_t")),
    ])

    Header.lookup("qom/object.h").add_types([
        Type("ObjectClass", False),
        Type("Object", False),
        Structure(
            "TypeInfo",
            fields=[
                # These are required fields only
                Pointer(Type.lookup("const char")).gen_var("name"),
                Pointer(Type.lookup("const char")).gen_var("parent"),
                Pointer(Type.lookup("void")).gen_var("class_init")
            ]),
        Type("Type", False),
        Type("TypeImpl", False),
        Function(name="type_register_static",
                 ret_type=Type.lookup("TypeImpl"),
                 args=[Type.lookup("TypeInfo").gen_var("info", pointer=True)]),
        Function(name="type_register",
                 ret_type=Type.lookup("TypeImpl"),
                 args=[Type.lookup("TypeInfo").gen_var("info", pointer=True)]),
        Function("object_get_typename"),
        Function("object_property_set_str"),
        Function("object_property_set_link"),
        Function("object_property_set_bool"),
        Function("object_property_set_int"),
        Function("object_class_by_name"),
        Function("object_class_dynamic_cast"),
        Function("object_class_is_abstract")
    ]).add_reference(osdep_fake_type)

    Header.lookup("qom/cpu.h").add_types([
        Type("CPUState", False),
        Type("CPUClass", False),
        Type("vaddr", False),
        Type("MMUAccessType", False),
        Type("CPUBreakpoint", False),
        Function("qemu_init_vcpu",
                 args=[Type.lookup("CPUState").gen_var("cpu", pointer=True)]),
        Function("cpu_exec_realizefn"),
        Function("cpu_reset"),
        Function("cpu_generic_init")
    ]).add_reference(osdep_fake_type)

    Header.lookup("qapi/error.h").add_types([Type("Error")
                                             ]).add_reference(osdep_fake_type)

    Header.lookup("disas/bfd.h").add_types([Type("disassemble_info", False)
                                            ]).add_reference(osdep_fake_type)

    Header.lookup("qemu/fprintf-fn.h").add_types(
        [Type("fprintf_function", False)]).add_reference(osdep_fake_type)

    Header.lookup("exec/exec-all.h").add_types([
        Type("TranslationBlock", False),
        Function("tlb_fill",
                 args=[
                     Type.lookup("CPUState").gen_var("cs", pointer=True),
                     Type.lookup("target_ulong").gen_var("addr"),
                     Type.lookup("MMUAccessType").gen_var("access_type"),
                     Type.lookup("int").gen_var("mmu_idx"),
                     Type.lookup("uintptr_t").gen_var("retaddr")
                 ],
                 used_types=[]),
        Function("cpu_exec_init",
                 args=[
                     Type.lookup("CPUState").gen_var("cs", pointer=True),
                     Pointer(Pointer(Type.lookup("Error"))).gen_var("errp")
                 ]),
        Function("gen_intermediate_code"),
        Function("cpu_restore_state"),
        Function("cpu_loop_exit"),
        Function("cpu_loop_exit_restore"),
        Function("tlb_set_page")
    ]).add_reference(osdep_fake_type)

    Header.lookup("exec/gen-icount.h").add_types(
        [Function("gen_tb_start"),
         Function("gen_tb_end")])

    Header.lookup("exec/address-spaces.h").add_types(
        [Function("get_system_memory")]).add_reference(osdep_fake_type)

    Header.lookup("exec/memory.h").add_types([
        Type("MemoryRegion", False),
        Function(name="MemoryRegionOps_read",
                 ret_type=Type.lookup("uint64_t"),
                 args=[
                     Type.lookup("void").gen_var("opaque", pointer=True),
                     Type.lookup("hwaddr").gen_var("offset"),
                     Type.lookup("unsigned").gen_var("size")
                 ]),
        Function(name="MemoryRegionOps_write",
                 ret_type=Type.lookup("void"),
                 args=[
                     Type.lookup("void").gen_var("opaque", pointer=True),
                     Type.lookup("hwaddr").gen_var("offset"),
                     Type.lookup("uint64_t").gen_var("value"),
                     Type.lookup("unsigned").gen_var("size")
                 ]),
        Structure("MemoryRegionOps", [
            Type.lookup("MemoryRegionOps_read").gen_var("read"),
            Type.lookup("MemoryRegionOps_write").gen_var("write"),
        ]),
        Function(
            name="memory_region_init_io",
            args=[
                Type.lookup("MemoryRegion").gen_var("mr", pointer=True),
                # struct
                Type.lookup("Object").gen_var("owner", pointer=True),
                # const
                Type.lookup("MemoryRegionOps").gen_var("ops", pointer=True),
                Type.lookup("void").gen_var("opaque", pointer=True),
                Type.lookup("const char").gen_var("name", pointer=True),
                Type.lookup("uint64_t").gen_var("size")
            ]),
        Function("memory_region_init"),
        Function("memory_region_init_alias"),
        Function("memory_region_init_ram"),
        Function("memory_region_add_subregion_overlap"),
        Function("memory_region_add_subregion")
    ]).add_reference(osdep_fake_type)

    Header.lookup("exec/gdbstub.h").add_types([
        Function(name="gdb_get_reg8"),
        Function(name="gdb_get_reg16"),
        Function(name="gdb_get_reg32"),
        Function(name="gdb_get_reg64")
    ]).add_reference(osdep_fake_type)

    Header.lookup("exec/ioport.h").add_types(
        [Type("pio_addr_t", incomplete=False)]).add_reference(osdep_fake_type)

    Header.lookup("hw/boards.h").add_types(
        [Structure("MachineClass"),
         Structure("MachineState")]).add_reference(osdep_fake_type)

    Header.lookup("hw/sysbus.h").add_types([
        Type("SysBusDevice", False),
        Type("qemu_irq", False),
        Function(name="sysbus_init_mmio",
                 ret_type=Type.lookup("void"),
                 args=[
                     Type.lookup("SysBusDevice").gen_var("dev", pointer=True),
                     Type.lookup("MemoryRegion").gen_var("memory",
                                                         pointer=True)
                 ]),
        Function(name="sysbus_init_irq",
                 ret_type=Type.lookup("void"),
                 args=[
                     Type.lookup("SysBusDevice").gen_var("dev", pointer=True),
                     Type.lookup("qemu_irq").gen_var("p", pointer=True)
                 ]),
        Function(name="sysbus_add_io",
                 ret_type=Type.lookup("void"),
                 args=[
                     Type.lookup("SysBusDevice").gen_var("dev", pointer=True),
                     Type.lookup("hwaddr").gen_var("addr"),
                     Type.lookup("MemoryRegion").gen_var("mem", pointer=True)
                 ]),
        Function(name="sysbus_init_ioports",
                 ret_type=Type.lookup("void"),
                 args=[
                     Type.lookup("SysBusDevice").gen_var("dev", pointer=True),
                     Type.lookup("pio_addr_t").gen_var("dev"),
                     Type.lookup("pio_addr_t").gen_var("dev")
                 ]),
        Function("sysbus_mmio_map"),
        Function("sysbus_connect_irq")
    ]).add_reference(osdep_fake_type)

    Header.lookup("hw/irq.h").add_types([
        Function(name="qemu_irq_handler",
                 ret_type=Type.lookup("void"),
                 args=[
                     Type.lookup("void").gen_var("opaque", pointer=True),
                     Type.lookup("int").gen_var("n"),
                     Type.lookup("int").gen_var("level")
                 ]),
        Function("qemu_irq_split")
    ]).add_reference(osdep_fake_type)

    Header.lookup("hw/qdev-core.h").add_types([
        Type("DeviceClass", False),
        Type("DeviceState", False),
        Type("Property", False),
        Function(name="qdev_init_gpio_in",
                 ret_type=Type.lookup("void"),
                 args=[
                     Type.lookup("DeviceState").gen_var("dev", pointer=True),
                     Type.lookup("qemu_irq_handler").gen_var("handler"),
                     Type.lookup("int").gen_var("n")
                 ]),
        Pointer(
            Function(name="device_realize pointee",
                     args=[
                         Type.lookup("DeviceState").gen_var("dev",
                                                            pointer=True),
                         Pointer(Type.lookup("Error")).gen_var("errp",
                                                               pointer=True)
                     ]),
            name="DeviceRealize",
        ),
        Function(name="qdev_create"),
        Function(name="qdev_init_nofail"),
        Function(name="qdev_get_child_bus"),
        Structure(name="BusState"),
        Function(name="qdev_get_gpio_in"),
        Function(name="qdev_get_gpio_in_named"),
        Function(name="qdev_connect_gpio_out"),
        Function(name="qdev_connect_gpio_out_named")
    ]).add_reference(osdep_fake_type)

    Header.lookup("migration/vmstate.h").add_types([
        Type("VMStateDescription", False),
        Type("VMStateField", False),
        Function("vmstate_register_ram_global")
    ]).add_reference(osdep_fake_type)

    Header.lookup("qemu/module.h").add_reference(osdep_fake_type)

    Header.lookup("hw/pci/pci.h").add_types([
        Type("PCIDevice", False),
        Type("PCIDeviceClass", False),
        Function("pci_create_multifunction"),
        Type("PCIIOMMUFunc"),
    ]).add_reference(osdep_fake_type)

    Header.lookup("hw/pci/msi.h").add_types([
        Function(name="msi_uninit",
                 ret_type=Type.lookup("void"),
                 args=[Type.lookup("PCIDevice").gen_var("dev", pointer=True)])
    ]).add_reference(osdep_fake_type)

    Header.lookup("hw/pci/pci_bus.h").add_types([
        Type("PCIBus", incomplete=True)
    ]).add_references([Type.lookup("PCIIOMMUFunc"), osdep_fake_type])
    Header.lookup("hw/pci/pci_host.h").add_reference(osdep_fake_type)

    Header.lookup("qemu/typedefs.h").add_types([
        # BlockBackend is defined in internal block_int.h. Its fields may not
        # be accessed outside internal code. Methods from block-backend.h must
        # be used instead.
        Structure("BlockBackend"),
        Structure("I2CBus")  # the structure is defined in .c file
    ]).add_reference(osdep_fake_type)

    Header.lookup("qemu/bswap.h").add_types(
        [Function("bswap64"),
         Function("bswap32"),
         Function("bswap16")]).add_reference(osdep_fake_type)

    Header.lookup("hw/ide/internal.h").add_types(
        [Structure("IDEDMA")]).add_reference(osdep_fake_type)

    Header.lookup("hw/ide/ahci.h").add_references(
        [Type.lookup("IDEDMA"), osdep_fake_type])

    Header.lookup("hw/block/flash.h").add_references(
        [Type.lookup("VMStateDescription"), osdep_fake_type])

    Header.lookup("qemu/timer.h").add_types([
        Structure("QEMUTimer"),
        Function("timer_new_ns"),
        Function("timer_del"),
        Function("timer_free"),
        Type("QEMU_CLOCK_VIRTUAL")  # It is enumeration entry...
    ]).add_references([osdep_fake_type])

    Header.lookup("qemu/main-loop.h").add_types([
        Function("IOCanReadHandler",
                 ret_type=Type.lookup("int"),
                 args=[Pointer(Type.lookup("void")).gen_var("opaque")]),
        Function("IOReadHandler",
                 args=[
                     Pointer(Type.lookup("void")).gen_var("opaque"),
                     Pointer(Type.lookup("uint8_t"),
                             const=True).gen_var("buf"),
                     Type.lookup("int").gen_var("size")
                 ])
    ]).add_references([osdep_fake_type])

    if get_vp()["v2.8 chardev"]:
        chardev_types = [
            Function("qemu_chr_fe_set_handlers"),
            Structure("CharBackend")
        ]
    else:
        chardev_types = [
            Function("qemu_chr_add_handlers"),
            Structure("CharDriverState")
        ]

    Header.lookup(get_vp("header with IOEventHandler")).add_types([
        Function("IOEventHandler",
                 args=[
                     Pointer(Type.lookup("void")).gen_var("opaque"),
                     Type.lookup("int").gen_var("event")
                 ])
    ] + chardev_types).add_references([osdep_fake_type])

    Header.lookup("sysemu/block-backend.h").add_types([
        Structure("BlockDevOps"),
    ]).add_references([osdep_fake_type])

    Header.lookup("hw/isa/isa.h").add_types([Type("IsaDmaTransferHandler")])

    if get_vp()["include/hw/isa/i8257.h have IsaDmaTransferHandler reference"]:
        Header.lookup(get_vp()["i8257.h path"]).add_references([
            Type.lookup("IsaDmaTransferHandler"),
            Type.lookup("MemoryRegion")
        ])

    Header.lookup("net/net.h").add_types([
        Type("qemu_macaddr_default_if_unset"),
        Type("qemu_format_nic_info_str"),
        Type("qemu_new_nic"),
        Type("qemu_del_nic"),
        Type("qemu_get_queue"),
        Structure("NICConf"),
        Type("NICState"),
        Type("NetClientState"),
        Function("NetCanReceive",
                 ret_type=Type.lookup("int"),
                 args=[Pointer(Type.lookup("NetClientState")).gen_var("nc")]),
        Function("NetReceive",
                 ret_type=Type.lookup("ssize_t"),
                 args=[
                     Pointer(Type.lookup("NetClientState")).gen_var("nc"),
                     Pointer(Type.lookup("const uint8_t")).gen_var("buf"),
                     Type.lookup("size_t").gen_var("size")
                 ]),
        Function("LinkStatusChanged",
                 args=[Pointer(Type.lookup("NetClientState")).gen_var("nc")]),
        Function("NetCleanup",
                 args=[Pointer(Type.lookup("NetClientState")).gen_var("nc")]),
        Structure(
            "NetClientInfo",
            fields=[
                # "type" field type is enum NetClientDriver, but enum is not
                # supported by model
                Type.lookup("int").gen_var("type"),
                Type.lookup("size_t").gen_var("size"),
                Type.lookup("NetReceive").gen_var("receive"),
                Type.lookup("NetCanReceive").gen_var("can_receive"),
                Type.lookup("NetCleanup").gen_var("cleanup"),
                Type.lookup("LinkStatusChanged").gen_var("link_status_changed")
                # There are other fields but they are not needed.
            ]),
        Macro("NET_CLIENT_DRIVER_NIC")  # This is an enum item actually. It
        # is defined in auto generated "qapi-types.h" which is not presented in
        # registry but is included by "net.h" indirectly.
    ]).add_references([osdep_fake_type])

    Header.lookup("exec/helper-proto.h").add_type(Macro("HELPER_PROTO_H"))

    Header.lookup("disas/bfd.h").add_types([
        Type("bfd_vma", False),
        Type("bfd_byte", False),
        Type("const bfd_tyte", False),
        Function("bfd_getl64",
                 ret_type=Type.lookup("bfd_vma"),
                 args=[
                     Pointer(Type.lookup("const bfd_tyte")).gen_var(
                         "addr", pointer=True)
                 ]),
        Function("bfd_getl32",
                 ret_type=Type.lookup("bfd_vma"),
                 args=[
                     Pointer(Type.lookup("const bfd_tyte")).gen_var(
                         "addr", pointer=True)
                 ]),
        Function("bfd_getb32",
                 ret_type=Type.lookup("bfd_vma"),
                 args=[
                     Pointer(Type.lookup("const bfd_tyte")).gen_var(
                         "addr", pointer=True)
                 ]),
        Function("bfd_getl16",
                 ret_type=Type.lookup("bfd_vma"),
                 args=[
                     Pointer(Type.lookup("const bfd_tyte")).gen_var(
                         "addr", pointer=True)
                 ]),
        Function("bfd_getb16",
                 ret_type=Type.lookup("bfd_vma"),
                 args=[
                     Pointer(Type.lookup("const bfd_tyte")).gen_var(
                         "addr", pointer=True)
                 ])
    ])

    Header.lookup("disas/disas.h").add_types([Function("lookup_symbol")])
    Header.lookup("qemu/log.h").add_types([
        Function("qemu_loglevel_mask"),
        Function("qemu_log_in_addr_range"),
        Function("qemu_log_lock"),
        Function("qemu_log_unlock"),
        Function("qemu_log")
    ])
    Header.lookup("exec/log.h").add_types([Function("log_target_disas")])