def setUp(self): super(TestPointerReferences, self).setUp() name = type(self).__name__ try: h = Header["type_a.h"] except: h = Header("type_a.h") h.add_type(Type("a", incomplete=False, base=False)) src = Source(name.lower() + ".c").add_type( Structure("s", Pointer(Type["a"])("next"))) src_content = """\ /* {} */ #include "type_a.h" typedef struct s {{ a *next; }} s; """.format(src.path) self.files = [(src, src_content)]
def __init__(self, name, directory, nic_num=0, timer_num=0, char_num=0, block_num=0, **qom_kw): super(QOMDevice, self).__init__(name, **qom_kw) self.directory = directory self.nic_num = nic_num self.timer_num = timer_num self.char_num = char_num self.block_num = block_num # Define header file header_path = join("hw", directory, self.qtn.for_header_name + ".h") try: self.header = Header.lookup(header_path) except Exception: self.header = Header(header_path) # Define source file source_path = join("hw", directory, self.qtn.for_header_name + ".c") self.source = Source(source_path)
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)]
def define_msi_init_2_6_0(): Header.lookup("hw/pci/msi.h").add_type( Function(name="msi_init", ret_type=Type.lookup("int"), args=[ Type.lookup("PCIDevice").gen_var("dev", pointer=True), Type.lookup("uint8_t").gen_var("offset"), Type.lookup("unsigned int").gen_var("nr_vectors"), Type.lookup("bool").gen_var("msi64bit"), Type.lookup("bool").gen_var("msi_per_vector_mask") ]))
def setUp(self): super(TestRedirectionToDeclaration, self).setUp() name = type(self).__name__ private_h = Header("private.h") private_h.add_type(Structure("Private")) public_h = Header("public.h") public_h.add_types([ Type["Private"].gen_forward_declaration(), Function("public_func") ]) private_c = Source("private.c") public_func_impl = Type["public_func"].gen_definition() private_c.add_type(public_func_impl) src = Source(name.lower() + ".c").add_global_variable( # It must internally re-direct pointer from type "Private" # to "Private.declaration", its forward declaration. Pointer(Type["Private"])("handler")) src.add_type(Pointer(public_func_impl, name="cb_ptr")) src_content = """\ /* %s */ #include "public.h" typedef void (*cb_ptr)(void); Private *handler __attribute__((unused)); """ % (name.lower() + ".c") self.files = [(src, src_content)]
def setUp(self): super(TestNamelessStructure, self).setUp() name = type(self).__name__ hdr = Header(name.lower() + ".h") hdr.add_type(Structure("a")) hdr.add_type(Structure("b", Type["int"]("f"))) hdr.add_type( Structure( "c", Structure(None, Type["int"]("f2"), Structure()("f3"))("f1"))) hdr_content = """\ /* {path} */ #ifndef INCLUDE_{fname_upper}_H #define INCLUDE_{fname_upper}_H typedef struct a {{}} a; typedef struct b {{ int f; }} b; typedef struct c {{ struct {{ int f2; struct {{}} f3; }} f1; }} c; #endif /* INCLUDE_{fname_upper}_H */ """.format(path=hdr.path, fname_upper=name.upper()) self.files = [(hdr, hdr_content)]
def provide_header(self): header_path = join("include", "hw", self.directory, self.qtn.for_header_name + ".h") try: return Header[header_path] except Exception: return Header(header_path)
def setUp(self): super(TestEnumerations, self).setUp() name = type(self).__name__ try: h = Header["enums.h"] except: h = Header("enums.h") h.add_type(Enumeration("A", [("one", 1), ("two", 2)])) a = Type["int"]("a") b = Type["int"]("b") c = Type["int"]("c") src = Source(name.lower() + ".c").add_types([ Enumeration("B", [("three", 3), ("four", 4)], "B"), Function(name="main", body=BodyTree()(Declare(a, b, c), OpAssign(a, Type["A"].one), OpAssign(b, Type["B"].three), OpAssign(c, Type["four"]))) ]) src_content = """\ /* {} */ #include "enums.h" enum B {{ three = 3, four = 4 }}; void main(void) {{ int a, b, c; a = one; b = three; c = four; }} """.format(src.path) self.files = [(src, src_content)]
def setUp(self): super(TestForwardDeclarationHeader, self).setUp() name = type(self).__name__ hdr = Header(name.lower() + ".h") src = Source(name.lower() + ".c") a = Structure("A") a.append_field(Pointer(a)("next")) b = Structure("B") b.append_field(Pointer(a)("next")) hdr.add_type(a) hdr_content = """\ /* {path} */ #ifndef INCLUDE_{fname_upper}_H #define INCLUDE_{fname_upper}_H typedef struct A A; struct A {{ A *next; }}; #endif /* INCLUDE_{fname_upper}_H */ """.format(path=hdr.path, fname_upper=name.upper()) src.add_type(b) src_content = """\ /* {} */ #include "{}" typedef struct B {{ A *next; }} B; """.format(src.path, hdr.path) self.files = [(hdr, hdr_content), (src, src_content)]
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)]
def setUp(self): super(TestAddingTypeToLockedHeader, self).setUp() name = type(self).__name__ Header("some_types.h").add_type(Type("t")) # Without locking "some_types.h" header will be included in # "lockedheader.h". Header("lockedheader.h", locked=True).add_type(Structure("S", Pointer(Type["t"])("f"))) hdr = Header(name.lower() + ".h") hdr.add_type(Pointer(Type["S"], name="ps")) hdr_content = """\ /* {path} */ #ifndef INCLUDE_{fname_upper}_H #define INCLUDE_{fname_upper}_H #include "some_types.h" #include "lockedheader.h" typedef S *ps; #endif /* INCLUDE_{fname_upper}_H */ """.format(path=hdr.path, fname_upper=name.upper()) self.files = [(hdr, hdr_content)]
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)]
def setUp(self): super(TestGlobalHeadersInclusion, self).setUp() name = type(self).__name__ hg = Header("global_types.h", is_global=True) hl = Header("local_types.h") hg.add_type(Type("GT", incomplete=False)) hl.add_type(Type("LT", incomplete=False)) hdr = Header(name.lower() + ".h").add_type( Structure("Fields", Type["GT"]("f1"), Type["LT"]("f2"))) hdr_content = """\ /* {path} */ #ifndef INCLUDE_{fname_upper}_H #define INCLUDE_{fname_upper}_H #include "local_types.h" typedef struct Fields {{ GT f1; LT f2; }} Fields; #endif /* INCLUDE_{fname_upper}_H */ """.format(path=hdr.path, fname_upper=name.upper()) src = Source(name.lower() + ".c").add_global_variable( Type["Fields"]("fv")) src_content = """\ /* {} */ #include <global_types.h> #include "{}" Fields fv __attribute__((unused)); """.format(src.path, hdr.path) self.files = [(hdr, hdr_content), (src, src_content)]
def fill_source(self): """ Adds a hook callback in MMIO read handler. """ super(CustomSBDType, self).fill_source() # Now, code of device's module is generated. It's time to patch it! # Assuming, your code uses functions and types from your header. custom_h = Header("custom-api.h", is_global=True) # If your header is inside Qemu source tree and under Git, then you # likely should write above statement as follows: # # custom_h = Header["custom/custom-api.h"] # # Because the header is already registered. # To use custom functions (and other things) you must declare them. # Note that, macros are added automatically if header is inside Qemu # source tree. # Only name is sufficient because no code will be generated for them. custom_h.add_types([Function("custom_callback")]) read_func = self.find_mmio_read_helper(0) # We are going to pass second and following argument values of the # read helper to the custom callback. # Of course, you can made different choice in your code. args2callback = read_func.args[1:] # Insert function call statement before 3-nd statement. # Note, first statements are likely variable declarations. # This is for prettiness only. read_func.body.children.insert(2, Call("custom_callback", *args2callback))
def setUp(self): super(TestHeaderInclusion, self).setUp() name = type(self).__name__ f = Function(name="test_f") f_def = f.gen_definition() hdr = Header(name.lower() + ".h").add_type(f) hdr_content = """\ /* {path} */ #ifndef INCLUDE_{fname_upper}_H #define INCLUDE_{fname_upper}_H void test_f(void); #endif /* INCLUDE_{fname_upper}_H */ """.format(path=hdr.path, fname_upper=name.upper()) src1 = Source(name.lower() + ".c").add_type(f_def) src1_content = """\ /* {} */ void test_f(void) {{}} """.format(src1.path) src2 = Source(name.lower() + "2.c").add_type( Function( name="func_a", body=BodyTree()( Call(f_def) # use function definition to Call ))) src2_content = """\ /* {} */ #include "{}" void func_a(void) {{ test_f(); }} """.format(src2.path, hdr.path) self.files = [(hdr, hdr_content), (src1, src1_content), (src2, src2_content)]
def co_init_cache(self): if self.qvc is not None: raise MultipleQVCInitialization(self.src_path) qvc_file_name = u"qvc_" + self.commit_sha + u".py" qvc_path = self.qvc_path = join(self.build_path, qvc_file_name) qemu_heuristic_hash = calculate_qh_hash() yield True if not isfile(qvc_path): yield self.co_check_untracked_files() self.qvc = QemuVersionCache() # make new QVC active and begin construction prev_qvc = self.qvc.use() for path in self.include_paths: yield Header.co_build_inclusions(path) self.qvc.list_headers = self.qvc.stc.create_header_db() yield self.co_check_modified_files() yield self.co_gen_device_tree() # gen version description yield self.qvc.co_computing_parameters(self.repo) self.qvc.version_desc[QVD_QH_HASH] = qemu_heuristic_hash # Search for PCI Ids PCIClassification.build() yield True PyGenerator().serialize(open(qvc_path, "wb"), self.qvc) else: self.load_cache() # make just loaded QVC active prev_qvc = self.qvc.use() if self.qvc.list_headers is not None: yield True self.qvc.stc.load_header_db(self.qvc.list_headers) yield True # verify that the version_desc is not outdated is_outdated = False try: checksum = self.qvc.version_desc[QVD_QH_HASH] except KeyError: is_outdated = True else: if not checksum == qemu_heuristic_hash: is_outdated = True if is_outdated: remove_file(qvc_path) yield self.qvc.co_computing_parameters(self.repo) self.qvc.version_desc[QVD_QH_HASH] = qemu_heuristic_hash PyGenerator().serialize(open(qvc_path, "wb"), self.qvc) yield True # set Qemu version heuristics according to current version initialize_version(self.qvc.version_desc) yield True # initialize Qemu types in QVC get_vp()["qemu types definer"]() get_vp()["msi_init type definer"]() if prev_qvc is not None: prev_qvc.use() self.qvc_is_ready = True
def setUp(self): super(TestOptimizeInclusions, self).setUp() name = type(self).__name__ src = Source(name.lower() + ".c") ah = Header("a.h") bh = Header("b.h") ch = Header("c.h") ah.add_type(Type("a")) bh.add_type(Type("b")).add_reference(Type["a"]) ch.add_type(Type("c")).add_reference(Type["b"]).add_inclusion(ah) src.add_type(Pointer(Type["c"], "cpointer")) # c.h includes a.h but inclusion of a.h cannot be substituted with c.h # inclusion because it creating reference loop between inclusions of # c.h and b.h. This test checks inclusions optimization correctness and # ordering of chunks. src_content = """\ /* {} */ #include "a.h" #include "b.h" #include "c.h" typedef c *cpointer; """.format(src.path) self.files = [(src, src_content)]
def define_qemu_2_6_0_types(): add_base_types() # The paths of the headers are presented relative root directory. Header("hw/ide/internal.h") Header("hw/ide/ahci.h") define_only_qemu_2_6_0_types()
def setUp(self): super(TestEnumerations, self).setUp() name = type(self).__name__ try: h = Header["enums.h"] except: h = Header("enums.h") h.add_type(Enumeration([("EXT", 1)])) src = Source(name.lower() + ".c").add_types([ Enumeration([("ONE", 1)]), Enumeration([("TWO", 2)], enum_name="A"), Enumeration([("THREE", 3)], typedef_name="B"), Enumeration([("FOUR", 4)], enum_name="C", typedef_name="D") ]) a = Type["int"]("a") b = Type["int"]("b") c = Type["A"]("c") d = Type["B"]("d") e = Type["D"]("e") src.add_types([ Function(name="main", body=BodyTree()(Declare(a, b), OpAssign(a, Type["EXT"]), OpAssign(b, Type["ONE"]), Declare(c), OpAssign(c, Type["TWO"]), Declare(d), OpAssign(d, Type["THREE"]), Declare(e), OpAssign(e, Type["FOUR"]))) ]) src_content = """\ /* {} */ #include "enums.h" enum A {{ TWO = 2 }}; typedef enum {{ THREE = 3 }} B; typedef enum C {{ FOUR = 4 }} D; enum {{ ONE = 1 }}; void main(void) {{ int a, b; a = EXT; b = ONE; enum A c; c = TWO; B d; d = THREE; D e; e = FOUR; }} """.format(src.path) self.files = [(src, src_content)]
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")])
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)]
def co_init_cache(self): if self.qvc is not None: print("Multiple QVC initialization " + self.src_path) self.qvc = None qvc_path = self.qvc_path = join(self.build_path, self.qvc_file_name) qemu_heuristic_hash = calculate_qh_hash() yield True if not isfile(qvc_path): self.qvc = QemuVersionCache() # Check out Qemu source to a temporary directory and analyze it # there. This avoids problems with user changes in main working # directory. print("Checking out temporary source tree...") # Note. Alternatively, checking out can be performed without # cloning. Instead, a magic might be casted on GIT_DIR and # GIT_WORK_TREE environment variables. But, this approach resets # staged files in src_path repository which can be inconvenient # for a user. tmp_repo = fast_repo_clone(self.repo, self.commit_sha, "qdt-qemu") tmp_work_dir = tmp_repo.working_tree_dir print("Temporary source tree: %s" % tmp_work_dir) # make new QVC active and begin construction prev_qvc = self.qvc.use() for path, recursive in self.include_paths: yield Header.co_build_inclusions(join(tmp_work_dir, path), recursive) self.qvc.list_headers = self.qvc.stc.create_header_db() rmtree(tmp_work_dir) yield self.co_init_device_tree() yield self.co_gen_known_targets() # gen version description yield self.qvc.co_computing_parameters(self.repo, self.commit_sha) self.qvc.version_desc[QVD_QH_HASH] = qemu_heuristic_hash # Search for PCI Ids PCIClassification.build() yield True pythonize(self.qvc, qvc_path) else: self.load_cache() # make just loaded QVC active prev_qvc = self.qvc.use() if self.qvc.list_headers is not None: yield True yield self.qvc.stc.co_load_header_db(self.qvc.list_headers) yield True # verify that the version_desc is not outdated is_outdated = False try: checksum = self.qvc.version_desc[QVD_QH_HASH] except KeyError: is_outdated = True else: if not checksum == qemu_heuristic_hash: is_outdated = True if is_outdated: yield self.qvc.co_computing_parameters(self.repo, self.commit_sha) self.qvc.version_desc[QVD_QH_HASH] = qemu_heuristic_hash dt = self.qvc.device_tree if dt: # Targets to be added to the cache new_targets = self.softmmu_targets - dt.arches has_new_target = len(new_targets) > 0 else: new_targets = self.softmmu_targets has_new_target = True if has_new_target: yield self.co_init_device_tree(new_targets) if is_outdated or has_new_target: pythonize(self.qvc, qvc_path) yield True # set Qemu version heuristics according to current version initialize_version(self.qvc.version_desc) yield True # initialize Qemu types in QVC get_vp()["qemu types definer"]() get_vp()["msi_init type definer"]() if prev_qvc is not None: prev_qvc.use() self.qvc_is_ready = True
def setUp(self): super(TestReferencingToTypeInAnotherHeader, self).setUp() name = type(self).__name__ hdr = Header(name.lower() + ".h") h1 = Header("some_types.h") h2 = Header("another_some_types.h") h1.add_type(Type("f1", incomplete=False)) h2.add_type(Type("f2", incomplete=False)) # Without reference headers `another_some_types` and `some_types` would # be in alphabetical order. h2.add_reference(Type["f1"]) s = Structure("S", Type["f1"]("field1"), Type["f2"]("field2")) hdr.add_type(s) hdr_content = """\ /* {path} */ #ifndef INCLUDE_{fname_upper}_H #define INCLUDE_{fname_upper}_H #include "some_types.h" #include "another_some_types.h" typedef struct S {{ f1 field1; f2 field2; }} S; #endif /* INCLUDE_{fname_upper}_H */ """.format(path=hdr.path, fname_upper=name.upper()) self.files = [(hdr, hdr_content)]