diff --git a/Makefile b/Makefile index 9ce4ad25..d86e4937 100644 --- a/Makefile +++ b/Makefile @@ -82,12 +82,6 @@ CC = $(CROSS)-gcc AR = $(CROSS)-ar RANLIB = $(CROSS)-ranlib STRIP = $(CROSS)-strip -GLIB = "-L/usr/$(CROSS)/lib/ -lglib-2.0" -endif - -# Find GLIB -ifndef GLIB -GLIB = `pkg-config --libs glib-2.0` endif ifeq ($(PKG_EXTRA),) @@ -195,7 +189,7 @@ else PKGCFGDIR ?= $(LIBDATADIR)/pkgconfig endif -$(LIBNAME)_LDFLAGS += $(GLIB) -lm +$(LIBNAME)_LDFLAGS += -lm .PHONY: all all: unicorn diff --git a/bindings/go/unicorn/unicorn.go b/bindings/go/unicorn/unicorn.go index 6ac3ecce..85bc39e8 100644 --- a/bindings/go/unicorn/unicorn.go +++ b/bindings/go/unicorn/unicorn.go @@ -8,7 +8,7 @@ import ( /* #cgo CFLAGS: -O3 -Wall -Werror -I../../../include -#cgo LDFLAGS: -L../../../ -lunicorn -lglib-2.0 +#cgo LDFLAGS: -L../../../ -lunicorn #include #include "uc.h" */ diff --git a/bindings/python/setup.py b/bindings/python/setup.py index 553e7f14..02cd5285 100755 --- a/bindings/python/setup.py +++ b/bindings/python/setup.py @@ -28,7 +28,6 @@ ALL_WINDOWS_DLLS = ( "libiconv-2.dll", "libpcre-1.dll", "libintl-8.dll", - "libglib-2.0-0.dll", ) # are we building from the repository or from a source distribution? diff --git a/bindings/python/unicorn/unicorn.py b/bindings/python/unicorn/unicorn.py index 549aa8ea..f5dd16b9 100644 --- a/bindings/python/unicorn/unicorn.py +++ b/bindings/python/unicorn/unicorn.py @@ -32,7 +32,6 @@ _all_windows_dlls = ( "libiconv-2.dll", "libpcre-1.dll", "libintl-8.dll", - "libglib-2.0-0.dll", ) _loaded_windows_dlls = set() diff --git a/make.sh b/make.sh index 048df624..ed6706ea 100755 --- a/make.sh +++ b/make.sh @@ -3,9 +3,6 @@ # Unicorn Engine # By Nguyen Anh Quynh , 2015 -# Note: to cross-compile to Windows on Linux, Mingw-glib2 is required. -# See README on how to install Mingw-glib2. - MAKE_JOBS=$((${MAKE_JOBS}+0)) [ ${MAKE_JOBS} -lt 1 ] && \ MAKE_JOBS=4 @@ -42,7 +39,6 @@ build_cross() { CC=$CROSS-gcc \ AR=$CROSS-gcc-ar \ RANLIB=$CROSS-gcc-ranlib \ - GLIB="-L/usr/$CROSS/lib/ -lglib-2.0" \ ${MAKE} } diff --git a/qemu/Makefile.objs b/qemu/Makefile.objs index e3bc755c..d3091e39 100644 --- a/qemu/Makefile.objs +++ b/qemu/Makefile.objs @@ -6,7 +6,7 @@ util-obj-y = util/ qobject/ qapi/ qapi-types.o qapi-visit.o # block-obj-y is code used by both qemu system emulation and qemu-img block-obj-y = -block-obj-y += ../uc.o ../list.o +block-obj-y += ../uc.o ../list.o glib_compat.o #block-obj-$(CONFIG_POSIX) += aio-posix.o #block-obj-$(CONFIG_WIN32) += aio-win32.o diff --git a/qemu/aarch64.h b/qemu/aarch64.h index e6a9675f..67adc0c2 100644 --- a/qemu/aarch64.h +++ b/qemu/aarch64.h @@ -2179,15 +2179,12 @@ #define object_property_find object_property_find_aarch64 #define object_property_get object_property_get_aarch64 #define object_property_get_bool object_property_get_bool_aarch64 -#define object_property_get_enum object_property_get_enum_aarch64 #define object_property_get_int object_property_get_int_aarch64 #define object_property_get_link object_property_get_link_aarch64 #define object_property_get_qobject object_property_get_qobject_aarch64 #define object_property_get_str object_property_get_str_aarch64 #define object_property_get_type object_property_get_type_aarch64 -#define object_property_get_uint16List object_property_get_uint16List_aarch64 #define object_property_is_child object_property_is_child_aarch64 -#define object_property_print object_property_print_aarch64 #define object_property_set object_property_set_aarch64 #define object_property_set_description object_property_set_description_aarch64 #define object_property_set_link object_property_set_link_aarch64 @@ -2427,7 +2424,6 @@ #define qemu_get_cpu qemu_get_cpu_aarch64 #define qemu_get_guest_memory_mapping qemu_get_guest_memory_mapping_aarch64 #define qemu_get_guest_simple_memory_mapping qemu_get_guest_simple_memory_mapping_aarch64 -#define qemu_get_local_state_pathname qemu_get_local_state_pathname_aarch64 #define qemu_get_ram_block qemu_get_ram_block_aarch64 #define qemu_get_ram_block_host_ptr qemu_get_ram_block_host_ptr_aarch64 #define qemu_get_ram_fd qemu_get_ram_fd_aarch64 @@ -2716,13 +2712,6 @@ #define string_input_get_visitor string_input_get_visitor_aarch64 #define string_input_visitor_cleanup string_input_visitor_cleanup_aarch64 #define string_input_visitor_new string_input_visitor_new_aarch64 -#define string_output_append string_output_append_aarch64 -#define string_output_append_range string_output_append_range_aarch64 -#define string_output_get_string string_output_get_string_aarch64 -#define string_output_get_visitor string_output_get_visitor_aarch64 -#define string_output_set string_output_set_aarch64 -#define string_output_visitor_cleanup string_output_visitor_cleanup_aarch64 -#define string_output_visitor_new string_output_visitor_new_aarch64 #define stristart stristart_aarch64 #define strongarm_cp_reginfo strongarm_cp_reginfo_aarch64 #define strpadcpy strpadcpy_aarch64 diff --git a/qemu/accel.c b/qemu/accel.c index 3de5416c..bd6f59b7 100644 --- a/qemu/accel.c +++ b/qemu/accel.c @@ -101,7 +101,7 @@ static AccelClass *accel_find(struct uc_struct *uc, const char *opt_name) { char *class_name = g_strdup_printf(ACCEL_CLASS_NAME("%s"), opt_name); AccelClass *ac = ACCEL_CLASS(uc, object_class_by_name(uc, class_name)); - g_free(class_name); + free(class_name); return ac; } diff --git a/qemu/arm.h b/qemu/arm.h index f365ad05..818f7acd 100644 --- a/qemu/arm.h +++ b/qemu/arm.h @@ -2179,15 +2179,12 @@ #define object_property_find object_property_find_arm #define object_property_get object_property_get_arm #define object_property_get_bool object_property_get_bool_arm -#define object_property_get_enum object_property_get_enum_arm #define object_property_get_int object_property_get_int_arm #define object_property_get_link object_property_get_link_arm #define object_property_get_qobject object_property_get_qobject_arm #define object_property_get_str object_property_get_str_arm #define object_property_get_type object_property_get_type_arm -#define object_property_get_uint16List object_property_get_uint16List_arm #define object_property_is_child object_property_is_child_arm -#define object_property_print object_property_print_arm #define object_property_set object_property_set_arm #define object_property_set_description object_property_set_description_arm #define object_property_set_link object_property_set_link_arm @@ -2427,7 +2424,6 @@ #define qemu_get_cpu qemu_get_cpu_arm #define qemu_get_guest_memory_mapping qemu_get_guest_memory_mapping_arm #define qemu_get_guest_simple_memory_mapping qemu_get_guest_simple_memory_mapping_arm -#define qemu_get_local_state_pathname qemu_get_local_state_pathname_arm #define qemu_get_ram_block qemu_get_ram_block_arm #define qemu_get_ram_block_host_ptr qemu_get_ram_block_host_ptr_arm #define qemu_get_ram_fd qemu_get_ram_fd_arm @@ -2716,13 +2712,6 @@ #define string_input_get_visitor string_input_get_visitor_arm #define string_input_visitor_cleanup string_input_visitor_cleanup_arm #define string_input_visitor_new string_input_visitor_new_arm -#define string_output_append string_output_append_arm -#define string_output_append_range string_output_append_range_arm -#define string_output_get_string string_output_get_string_arm -#define string_output_get_visitor string_output_get_visitor_arm -#define string_output_set string_output_set_arm -#define string_output_visitor_cleanup string_output_visitor_cleanup_arm -#define string_output_visitor_new string_output_visitor_new_arm #define stristart stristart_arm #define strongarm_cp_reginfo strongarm_cp_reginfo_arm #define strpadcpy strpadcpy_arm diff --git a/qemu/configure b/qemu/configure index c3ed462b..78c048f9 100755 --- a/qemu/configure +++ b/qemu/configure @@ -1087,34 +1087,6 @@ if test -n "$libtool"; then fi fi -########################################## -# glib support probe - -if test "$mingw32" = yes; then - # g_poll is required in order to integrate with the glib main loop. - glib_req_ver=2.20 -else - glib_req_ver=2.12 -fi -glib_modules=gthread-2.0 - -for i in $glib_modules; do - if $pkg_config --atleast-version=$glib_req_ver $i; then - glib_cflags=`$pkg_config --cflags $i` - glib_libs=`$pkg_config --libs $i` - CFLAGS="$glib_cflags $CFLAGS" - LIBS="$glib_libs $LIBS" - else - error_exit "glib-$glib_req_ver $i is required to compile QEMU" - fi -done - -# g_test_trap_subprocess added in 2.38. Used by some tests. -glib_subprocess=yes -if ! $pkg_config --atleast-version=2.38 glib-2.0; then - glib_subprocess=no -fi - ########################################## # pthread probe PTHREADLIBS_LIST="-pthread -lpthread -lpthreadGC2" @@ -1599,10 +1571,6 @@ fi if test "$bswap_h" = "yes" ; then echo "CONFIG_MACHINE_BSWAP_H=y" >> $config_host_mak fi -if test "glib_subprocess" = "yes" ; then - echo "CONFIG_HAS_GLIB_SUBPROCESS_TESTS=y" >> $config_host_mak -fi -echo "GLIB_CFLAGS=$glib_cflags" >> $config_host_mak if test "$signalfd" = "yes" ; then echo "CONFIG_SIGNALFD=y" >> $config_host_mak fi diff --git a/qemu/cpus.c b/qemu/cpus.c index bf391467..78edfa08 100644 --- a/qemu/cpus.c +++ b/qemu/cpus.c @@ -108,7 +108,7 @@ static void *qemu_tcg_cpu_loop(struct uc_struct *uc) cpu->created = false; qemu_cond_destroy(cpu->halt_cond); - g_free(cpu->halt_cond); + free(cpu->halt_cond); cpu->halt_cond = NULL; qemu_mutex_unlock(&uc->qemu_global_mutex); diff --git a/qemu/exec.c b/qemu/exec.c index 92f26641..21add4fb 100644 --- a/qemu/exec.c +++ b/qemu/exec.c @@ -517,7 +517,7 @@ void cpu_watchpoint_remove_by_ref(CPUState *cpu, CPUWatchpoint *watchpoint) tlb_flush_page(cpu, watchpoint->vaddr); - g_free(watchpoint); + free(watchpoint); } /* Remove all matching watchpoints. */ @@ -610,7 +610,7 @@ void cpu_breakpoint_remove_by_ref(CPUState *cpu, CPUBreakpoint *breakpoint) breakpoint_invalidate(cpu, breakpoint->pc); - g_free(breakpoint); + free(breakpoint); #endif } @@ -814,7 +814,7 @@ static void phys_section_destroy(MemoryRegion *mr) if (mr->subpage) { subpage_t *subpage = container_of(mr, subpage_t, iomem); object_unref(mr->uc, OBJECT(&subpage->iomem)); - g_free(subpage); + free(subpage); } } @@ -824,8 +824,8 @@ static void phys_sections_free(PhysPageMap *map) MemoryRegionSection *section = &map->sections[--map->sections_nb]; phys_section_destroy(section->mr); } - g_free(map->sections); - g_free(map->nodes); + free(map->sections); + free(map->nodes); } static void register_subpage(struct uc_struct* uc, @@ -1086,7 +1086,7 @@ ram_addr_t qemu_ram_alloc_from_ptr(ram_addr_t size, void *host, } addr = ram_block_add(mr->uc, new_block, &local_err); if (local_err) { - g_free(new_block); + free(new_block); error_propagate(errp, local_err); return -1; } @@ -1109,7 +1109,7 @@ void qemu_ram_free_from_ptr(struct uc_struct *uc, ram_addr_t addr) QTAILQ_REMOVE(&uc->ram_list.blocks, block, next); uc->ram_list.mru_block = NULL; uc->ram_list.version++; - g_free(block); + free(block); break; } } @@ -1137,7 +1137,7 @@ void qemu_ram_free(struct uc_struct *uc, ram_addr_t addr) } else { qemu_anon_ram_free(block->host, block->length); } - g_free(block); + free(block); break; } } @@ -1457,7 +1457,7 @@ MemoryRegion *iotlb_to_region(AddressSpace *as, hwaddr index) void phys_mem_clean(struct uc_struct* uc) { AddressSpaceDispatch* d = uc->as.next_dispatch; - g_free(d->map.sections); + free(d->map.sections); } static void mem_begin(MemoryListener *listener) @@ -1494,7 +1494,7 @@ static void mem_commit(MemoryListener *listener) if (cur) { phys_sections_free(&cur->map); - g_free(cur); + free(cur); } } @@ -1531,13 +1531,13 @@ void address_space_destroy_dispatch(AddressSpace *as) AddressSpaceDispatch *d = as->dispatch; memory_listener_unregister(as->uc, &as->dispatch_listener); - g_free(d->map.nodes); - g_free(d); + free(d->map.nodes); + free(d); if (as->dispatch != as->next_dispatch) { d = as->next_dispatch; - g_free(d->map.nodes); - g_free(d); + free(d->map.nodes); + free(d); } as->dispatch = NULL; diff --git a/qemu/glib_compat.c b/qemu/glib_compat.c new file mode 100644 index 00000000..dc9ea04d --- /dev/null +++ b/qemu/glib_compat.c @@ -0,0 +1,707 @@ +/* +glib_compat.c replacement functionality for glib code used in qemu +Copyright (C) 2016 Chris Eagle cseagle at gmail dot com + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +*/ + +#ifndef _GNU_SOURCE +#define _GNU_SOURCE +#endif + +#include +#include +#include + +#include "glib_compat.h" + +#ifdef _WIN32 + #ifdef _WIN64 + #define __HAVE_64_BIT_PTRS + #else + #define __HAVE_32_BIT_PTRS + #endif +#else + #ifdef _WIN64 + #define __HAVE_64_BIT_PTRS + #endif +#endif + +#ifdef __GNUC__ + #ifdef __x86_64__ + #define __HAVE_64_BIT_PTRS + #else + #ifdef __ppc64__ + #define __HAVE_64_BIT_PTRS + #else + #ifdef __aarch64__ + #define __HAVE_64_BIT_PTRS + #else + #define __HAVE_32_BIT_PTRS + #endif + #endif + #endif +#endif + +/* All functions below added to eliminate GLIB dependency */ + +/* hashing and equality functions */ + +/* + Too many pointers are multiples of 8/16 so I rotate the low bits out + otherwise we get too many collisions at multiples of 8/16 + This may be marginally better than what glib does in their direct_hash + but someone with some chops in this space should fix if it needs improving +*/ +uint32_t g_direct_hash(const void *v) { +#ifdef __HAVE_64_BIT_PTRS + uint64_t hash = (uint64_t)v; + hash = (hash >> 4) | (hash << 60); + hash = hash ^ (hash >> 32); + return (uint32_t)hash; +#else + uint32_t hash = (uint32_t)v; + hash = (hash >> 3) | (hash << 29); + return hash; +#endif +} + +int g_direct_equal(const void *v1, const void *v2) { + return v1 == v2; +} + +/* + djb2+ string hashing + see: http://www.cse.yorku.ca/~oz/hash.html +*/ +uint32_t g_str_hash(const void *v) { + const char *s = (const char*)v; + uint32_t hash = 5381; + while (*s) { + hash = ((hash << 5) + hash) ^ (int)*s; + s++; + } + return hash; +} + +int g_str_equal(const void *v1, const void *v2) { + return strcmp((const char*)v1, (const char*)v2) == 0; +} + +/* + Bob Jenkins integer hash algorithm + see: http://burtleburtle.net/bob/hash/integer.html +*/ +uint32_t g_int_hash(const void *v) { + uint32_t hash = *(const uint32_t*)v; + hash = (hash + 0x7ed55d16) + (hash << 12); + hash = (hash ^ 0xc761c23c) ^ (hash >> 19); + hash = (hash + 0x165667b1) + (hash << 5); + hash = (hash + 0xd3a2646c) ^ (hash << 9); + hash = (hash + 0xfd7046c5) + (hash << 3); + hash = (hash ^ 0xb55a4f09) ^ (hash >> 16); + return hash; +} + +int g_int_equal(const void *v1, const void *v2) { + return *(const int*)v1 == *(const int*)v2; +} + +/* Doubly-linked list */ + +GList *g_list_first(GList *list) { + if (list == NULL) return NULL; + while (list->prev) list = list->prev; + return list; +} + +void g_list_foreach(GList *list, list_func func, void* user_data) { + GList *lp; + for (lp = list; lp; lp = lp->next) { + (*func)(lp->data, user_data); + } +} + +void g_list_free(GList *list) { + GList *lp, *next, *prev = NULL; + if (list) prev = list->prev; + for (lp = list; lp; lp = next) { + next = lp->next; + free(lp); + } + for (lp = prev; lp; lp = prev) { + prev = lp->prev; + free(lp); + } +} + +GList *g_list_insert_sorted(GList *list, void* data, compare_func compare) { + GList *i; + GList *n = (GList*)g_malloc(sizeof(GList)); + n->data = data; + if (list == NULL) { + n->next = n->prev = NULL; + return n; + } + for (i = list; i; i = i->next) { + n->prev = i->prev; + if ((*compare)(data, i->data) <= 0) { + n->next = i; + i->prev = n; + if (i == list) return n; + else return list; + } + } + n->prev = n->prev->next; + n->next = NULL; + n->prev->next = n; + return list; +} + +GList *g_list_prepend(GList *list, void* data) { + GList *n = (GList*)g_malloc(sizeof(GList)); + n->next = list; + n->prev = NULL; + n->data = data; + return n; +} + +GList *g_list_remove_link(GList *list, GList *llink) { + if (llink == list) list = list->next; + if (llink->prev) llink->prev->next = llink->next; + if (llink->next) llink->next->prev = llink->prev; + return list; +} + +GList *g_list_sort(GList *list, compare_func compare) { + GList *i, *it, *j; + /* base case for singletons or empty lists */ + if (list == NULL || list->next == NULL) return list; + i = list; + j = i->next; + /* i walks half as fast as j, ends up in middle */ + while (j) { + j = j->next; + if (j) { + i = i->next; + j = j->next; + } + } + /* split the list midway */ + j = i->next; + j->prev = NULL; /* make j the head of its own list */ + i->next = NULL; + /* will never have NULL return from either call below */ + i = g_list_sort(list, compare); + j = g_list_sort(j, compare); + if ((*compare)(i->data, j->data) <= 0) { + list = i; + i = i->next; + } + else { + list = j; + j = j->next; + } + it = list; + while (i && j) { + if ((*compare)(i->data, j->data) <= 0) { + it->next = i; + i = i->next; + } + else { + it->next = j; + j = j->next; + } + it = it->next; + } + if (i) it->next = i; + else it->next = j; + return list; +} + +/* END of g_list related functions */ + +/* Singly-linked list */ + +GSList *g_slist_append(GSList *list, void* data) { + GSList *head = list; + if (list) { + while (list->next) list = list->next; + list->next = (GSList*)g_malloc(sizeof(GSList)); + list = list->next; + } + else { + head = list = (GSList*)g_malloc(sizeof(GSList)); + } + list->data = data; + list->next = NULL; + return head; +} + +void g_slist_foreach(GSList *list, list_func func, void* user_data) { + GSList *lp; + for (lp = list; lp; lp = lp->next) { + (*func)(lp->data, user_data); + } +} + +void g_slist_free(GSList *list) { + GSList *lp, *next; + for (lp = list; lp; lp = next) { + next = lp->next; + free(lp); + } +} + +void g_slist_free_full(GSList *list, GDestroyNotify free_func) { + GSList *lp, *next; + for (lp = list; lp; lp = next) { + next = lp->next; + if (free_func) (*free_func)(lp->data); + free(lp); + } +} + +GSList *g_slist_prepend(GSList *list, void* data) { + GSList *head = (GSList*)g_malloc(sizeof(GSList)); + head->next = list; + head->data = data; + return head; +} + +GSList *g_slist_sort(GSList *list, compare_func compare) { + GSList *i, *it, *j; + /* base case for singletons or empty lists */ + if (list == NULL || list->next == NULL) return list; + i = list; + j = i->next; + /* i walks half as fast as j, ends up in middle */ + while (j) { + j = j->next; + if (j) { + i = i->next; + j = j->next; + } + } + /* split the list midway */ + j = i->next; + i->next = NULL; + /* will never have NULL return from either call below */ + i = g_slist_sort(list, compare); + j = g_slist_sort(j, compare); + if ((*compare)(i->data, j->data) <= 0) { + list = i; + i = i->next; + } + else { + list = j; + j = j->next; + } + it = list; + while (i && j) { + if ((*compare)(i->data, j->data) <= 0) { + it->next = i; + i = i->next; + } + else { + it->next = j; + j = j->next; + } + it = it->next; + } + if (i) it->next = i; + else it->next = j; + return list; +} + +GSList *g_slist_find_custom(GSList *list, const void *data, compare_func func) { + GSList *lp; + for (lp = list; lp; lp = lp->next) { + if ((*func)(lp->data, data) == 0) return lp; + } + return NULL; +} + +GSList *g_slist_remove(GSList *list, const void *data) { + GSList *lp, *prev = NULL; + for (lp = list; lp; lp = lp->next) { + if (lp->data == data) { + if (prev == NULL) { + list = lp->next; + } + else { + prev->next = lp->next; + } + free(lp); + break; + } + prev = lp; + } + return list; +} + +/* END of g_slist related functions */ + + +/* Hash table */ + +typedef struct _KeyValue { + void *key; + void *value; +} KeyValue; + +typedef struct _GHashTable { + GHashFunc hash_func; + GEqualFunc key_equal_func; + GDestroyNotify key_destroy_func; + GDestroyNotify value_destroy_func; + uint32_t refcount; + uint32_t size; + uint32_t num_entries; + GSList **buckets; +} GHashTable; + +void g_hash_table_destroy(GHashTable *hash_table) { + if (hash_table == NULL) return; + g_hash_table_remove_all(hash_table); + g_hash_table_unref(hash_table); +} + +void* g_hash_table_find(GHashTable *hash_table, GHRFunc predicate, void* user_data) { + if (hash_table == NULL) return NULL; + int i; + for (i = 0; i < hash_table->size; i++) { + GSList *lp; + for (lp = hash_table->buckets[i]; lp; lp = lp->next) { + KeyValue *kv = (KeyValue*)(lp->data); + if ((*predicate)(kv->key, kv->value, user_data)) return kv->value; + } + } + return NULL; +} + +void g_hash_table_foreach(GHashTable *hash_table, GHFunc func, void* user_data) { + if (hash_table == NULL) return; + int i; + for (i = 0; i < hash_table->size; i++) { + GSList *lp; + for (lp = hash_table->buckets[i]; lp; lp = lp->next) { + KeyValue *kv = (KeyValue*)(lp->data); + (*func)(kv->key, kv->value, user_data); + } + } +} + +int g_hash_table_insert(GHashTable *hash_table, void* key, void* value) { + if (hash_table == NULL) return 1; + GSList *lp; + uint32_t hash = (*hash_table->hash_func)(key); + int bnum = hash % hash_table->size; + for (lp = hash_table->buckets[bnum]; lp; lp = lp->next) { + KeyValue *kv = (KeyValue*)(lp->data); + int match = hash_table->key_equal_func ? (*hash_table->key_equal_func)(kv->key, key) : (kv->key == key); + if (match) { + /* replace */ + kv->value = value; + return 0; + } + } + /* new key */ + KeyValue *pair = (KeyValue*)g_malloc(sizeof(KeyValue)); + pair->key = key; + pair->value = value; + hash_table->buckets[bnum] = g_slist_prepend(hash_table->buckets[bnum], pair); + hash_table->num_entries++; + /* grow and rehash at num_entries / size == ??? */ + return 1; +} + +void* g_hash_table_lookup(GHashTable *hash_table, const void* key) { + if (hash_table == NULL) return NULL; + GSList *lp; + uint32_t hash = (*hash_table->hash_func)(key); + int bnum = hash % hash_table->size; + for (lp = hash_table->buckets[bnum]; lp; lp = lp->next) { + KeyValue *kv = (KeyValue*)(lp->data); + int match = hash_table->key_equal_func ? (*hash_table->key_equal_func)(kv->key, key) : (kv->key == key); + if (match) { + return kv->value; + } + } + return NULL; +} + +GHashTable *g_hash_table_new(GHashFunc hash_func, GEqualFunc key_equal_func) { + return g_hash_table_new_full(hash_func, key_equal_func, NULL, NULL); +} + +GHashTable *g_hash_table_new_full(GHashFunc hash_func, GEqualFunc key_equal_func, + GDestroyNotify key_destroy_func, GDestroyNotify value_destroy_func) { + GHashTable *ht = (GHashTable*)g_malloc(sizeof(GHashTable)); + ht->hash_func = hash_func ? hash_func : g_direct_hash; + ht->key_equal_func = key_equal_func; + ht->key_destroy_func = key_destroy_func; + ht->value_destroy_func = value_destroy_func; + g_hash_table_ref(ht); + ht->size = 512; + ht->num_entries = 0; + ht->buckets = (GSList **)g_new0_(sizeof(GSList*), ht->size); + return ht; +} + +void g_hash_table_remove_all(GHashTable *hash_table) { + if (hash_table == NULL) return; + int i; + for (i = 0; i < hash_table->size; i++) { + GSList *lp; + for (lp = hash_table->buckets[i]; lp; lp = lp->next) { + KeyValue *kv = (KeyValue*)lp->data; + if (hash_table->key_destroy_func) (*hash_table->key_destroy_func)(kv->key); + if (hash_table->value_destroy_func) (*hash_table->value_destroy_func)(kv->value); + free(lp->data); + } + g_slist_free(hash_table->buckets[i]); + hash_table->buckets[i] = NULL; + } + hash_table->num_entries = 0; +} + +int g_hash_table_remove(GHashTable *hash_table, const void* key) { + GSList *lp, *prev = NULL; + if (hash_table == NULL) return 0; + uint32_t hash = (*hash_table->hash_func)(key); + int bnum = hash % hash_table->size; + for (lp = hash_table->buckets[bnum]; lp; lp = lp->next) { + KeyValue *kv = (KeyValue*)(lp->data); + int match = hash_table->key_equal_func ? (*hash_table->key_equal_func)(kv->key, key) : (kv->key == key); + if (match) { + if (hash_table->key_destroy_func) (*hash_table->key_destroy_func)(kv->key); + if (hash_table->value_destroy_func) (*hash_table->value_destroy_func)(kv->value); + free(kv); + if (prev == NULL) { + hash_table->buckets[bnum] = lp->next; + } + else { + prev->next = lp->next; + } + free(lp); + return 1; + } + prev = lp; + } + return 0; +} + +void g_hash_table_unref(GHashTable *hash_table) { + if (hash_table == NULL) return; + hash_table->refcount--; + if (hash_table->refcount == 0) { + free(hash_table->buckets); + free(hash_table); + } +} + +GHashTable *g_hash_table_ref(GHashTable *hash_table) { + if (hash_table == NULL) return NULL; + hash_table->refcount++; + return hash_table; +} + +uint32_t g_hash_table_size(GHashTable *hash_table) { + return hash_table ? hash_table->num_entries : 0; +} + + +/* END of g_hash_table related functions */ + +/* general g_XXX substitutes */ + +void *g_malloc(size_t size) { + if (size == 0) return NULL; + void *res = malloc(size); + if (res == NULL) exit(1); + return res; +} + +void *g_malloc0(size_t size) { + if (size == 0) return NULL; + void *res = calloc(size, 1); + if (res == NULL) exit(1); + return res; +} + +void *g_try_malloc0(size_t size) { + if (size == 0) return NULL; + void *res = calloc(size, 1); + return res; +} + +void *g_realloc(void *ptr, size_t size) { + if (size == 0) { + free(ptr); + return NULL; + } + void *res = realloc(ptr, size); + if (res == NULL) exit(1); + return res; +} + +char *g_strdup(const char *str) { + return str ? strdup(str) : NULL; +} + +char *g_strdup_printf(const char *format, ...) { + va_list ap; + char *res; + va_start(ap, format); + res = g_strdup_vprintf(format, ap); + va_end(ap); + return res; +} + +char *g_strdup_vprintf(const char *format, va_list ap) { + char *str_res = NULL; + vasprintf(&str_res, format, ap); + return str_res; +} + +char *g_strndup(const char *str, size_t n) { + /* try to mimic glib's g_strndup */ + char *res = calloc(n + 1, 1); + strncpy(res, str, n); + return res; +} + +void g_strfreev(char **str_array) { + char **p = str_array; + if (p) { + while (*p) { + free(*p++); + } + } + free(str_array); +} + +void *g_memdup(const void *mem, size_t byte_size) { + if (mem) { + void *res = g_malloc(byte_size); + memcpy(res, mem, byte_size); + return res; + } + return NULL; +} + +void *g_new_(size_t sz, size_t n_structs) { + size_t need = sz * n_structs; + if ((need / sz) != n_structs) return NULL; + return g_malloc(need); +} + +void *g_new0_(size_t sz, size_t n_structs) { + size_t need = sz * n_structs; + if ((need / sz) != n_structs) return NULL; + return g_malloc0(need); +} + +void *g_renew_(size_t sz, void *mem, size_t n_structs) { + size_t need = sz * n_structs; + if ((need / sz) != n_structs) return NULL; + return g_realloc(mem, need); +} + +char *g_strconcat (const char *string1, ...) { + va_list ap; + char *res; + size_t sz = strlen(string1); + va_start(ap, string1); + while (1) { + char *arg = va_arg(ap, char*); + if (arg == NULL) break; + sz += strlen(arg); + } + va_end(ap); + res = g_malloc(sz + 1); + strcpy(res, string1); + va_start(ap, string1); + while (1) { + char *arg = va_arg(ap, char*); + if (arg == NULL) break; + strcat(res, arg); + } + va_end(ap); + return res; +} + +char **g_strsplit(const char *string, const char *delimiter, int max_tokens) { + char **res; + if (string == NULL || *string == 0) { + res = (char**)g_malloc(sizeof(char*)); + *res = NULL; + } + else { + uint32_t ntokens, i, max = (uint32_t) max_tokens; + if (max == 0) max--; + int dlen = strlen(delimiter); + const char *p = string, *b; + for (ntokens = 1; ntokens < max; ntokens++) { + p = strstr(p, delimiter); + if (p == NULL) break; + p += dlen; + } + res = (char**)g_new_(sizeof(char*), ntokens + 1); + p = string; + for (b = p, i = 0; i < ntokens; b = p, i++) { + int len; + if (i == (ntokens - 1)) { + /* last piece special handling */ + res[i] = strdup(b); + } + else { + p = strstr(b, delimiter); + len = p - b; + res[i] = (char*)g_malloc(len + 1); + memcpy(res[i], b, len); + res[i][len] = 0; + p += dlen; + } + } + res[ntokens] = NULL; + } + return res; +} + +#ifdef _WIN32 + +#include + +char *g_win32_error_message(int error) { + char *msg; + char *winMsg = NULL; + if (error == 0) { + return (char*)g_malloc0(1); + } + + FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&msg, 0, NULL); + + /* give the caller something they can just free */ + msg = strdup(winMsg); + /* Free the allocated message. */ + HeapFree(GetProcessHeap(), 0, winMsg); + + return msg; +} + +#endif diff --git a/qemu/header_gen.py b/qemu/header_gen.py index 166e419e..30b7fd0e 100644 --- a/qemu/header_gen.py +++ b/qemu/header_gen.py @@ -2185,15 +2185,12 @@ symbols = ( 'object_property_find', 'object_property_get', 'object_property_get_bool', - 'object_property_get_enum', 'object_property_get_int', 'object_property_get_link', 'object_property_get_qobject', 'object_property_get_str', 'object_property_get_type', - 'object_property_get_uint16List', 'object_property_is_child', - 'object_property_print', 'object_property_set', 'object_property_set_description', 'object_property_set_link', @@ -2433,7 +2430,6 @@ symbols = ( 'qemu_get_cpu', 'qemu_get_guest_memory_mapping', 'qemu_get_guest_simple_memory_mapping', - 'qemu_get_local_state_pathname', 'qemu_get_ram_block', 'qemu_get_ram_block_host_ptr', 'qemu_get_ram_fd', @@ -2722,13 +2718,6 @@ symbols = ( 'string_input_get_visitor', 'string_input_visitor_cleanup', 'string_input_visitor_new', - 'string_output_append', - 'string_output_append_range', - 'string_output_get_string', - 'string_output_get_visitor', - 'string_output_set', - 'string_output_visitor_cleanup', - 'string_output_visitor_new', 'stristart', 'strongarm_cp_reginfo', 'strpadcpy', diff --git a/qemu/hw/core/qdev.c b/qemu/hw/core/qdev.c index 14e3ccec..0c79225b 100644 --- a/qemu/hw/core/qdev.c +++ b/qemu/hw/core/qdev.c @@ -176,7 +176,7 @@ static int device_set_realized(struct uc_struct *uc, Object *obj, bool value, Er object_property_add_child(container_get(qdev_get_machine(), "/unattached"), name, obj, &error_abort); - g_free(name); + free(name); } #endif @@ -305,7 +305,7 @@ static void qbus_finalize(struct uc_struct *uc, Object *obj, void *opaque) { BusState *bus = BUS(uc, obj); - g_free((char *)bus->name); + free((char *)bus->name); } static const TypeInfo bus_info = { diff --git a/qemu/hw/sparc/sun4m.c b/qemu/hw/sparc/sun4m.c index 3e9ac2b7..c7828388 100644 --- a/qemu/hw/sparc/sun4m.c +++ b/qemu/hw/sparc/sun4m.c @@ -745,7 +745,7 @@ static void prom_init(hwaddr addr, const char *bios_name) if (ret < 0 || ret > PROM_SIZE_MAX) { ret = load_image_targphys(filename, addr, PROM_SIZE_MAX); } - g_free(filename); + free(filename); } else { ret = -1; } diff --git a/qemu/include/glib-compat.h b/qemu/include/glib-compat.h deleted file mode 100644 index f0615c99..00000000 --- a/qemu/include/glib-compat.h +++ /dev/null @@ -1,201 +0,0 @@ -/* - * GLIB Compatibility Functions - * - * Copyright IBM, Corp. 2013 - * - * Authors: - * Anthony Liguori - * Michael Tokarev - * Paolo Bonzini - * - * This work is licensed under the terms of the GNU GPL, version 2 or later. - * See the COPYING file in the top-level directory. - * - */ - -#ifndef QEMU_GLIB_COMPAT_H -#define QEMU_GLIB_COMPAT_H - -#include - -/* GLIB version compatibility flags */ -#if !GLIB_CHECK_VERSION(2, 26, 0) -#define G_TIME_SPAN_SECOND (G_GINT64_CONSTANT(1000000)) -#endif - -#if !GLIB_CHECK_VERSION(2, 14, 0) -static inline guint g_timeout_add_seconds(guint interval, GSourceFunc function, - gpointer data) -{ - return g_timeout_add(interval * 1000, function, data); -} -#endif - -#if !GLIB_CHECK_VERSION(2, 28, 0) -static inline gint64 g_get_monotonic_time(void) -{ - /* g_get_monotonic_time() is best-effort so we can use the wall clock as a - * fallback. - */ - - GTimeVal time; - g_get_current_time(&time); - - return time.tv_sec * G_TIME_SPAN_SECOND + time.tv_usec; -} -#endif - -#if !GLIB_CHECK_VERSION(2, 16, 0) -static inline int g_strcmp0(const char *str1, const char *str2) -{ - int result; - - if (!str1) { - result = -(str1 != str2); - } else if (!str2) { - result = (str1 != str2); - } else { - result = strcmp(str1, str2); - } - - return result; -} -#endif - -#ifdef _WIN32 -/* - * g_poll has a problem on Windows when using - * timeouts < 10ms, so use wrapper. - */ -#define g_poll(fds, nfds, timeout) g_poll_fixed(fds, nfds, timeout) -gint g_poll_fixed(GPollFD *fds, guint nfds, gint timeout); -#elif !GLIB_CHECK_VERSION(2, 20, 0) -/* - * Glib before 2.20.0 doesn't implement g_poll, so wrap it to compile properly - * on older systems. - */ -static inline gint g_poll(GPollFD *fds, guint nfds, gint timeout) -{ - GMainContext *ctx = g_main_context_default(); - return g_main_context_get_poll_func(ctx)(fds, nfds, timeout); -} -#endif - -#if !GLIB_CHECK_VERSION(2, 31, 0) -/* before glib-2.31, GMutex and GCond was dynamic-only (there was a separate - * GStaticMutex, but it didn't work with condition variables). - * - * Our implementation uses GOnce to fake a static implementation that does - * not require separate initialization. - * We need to rename the types to avoid passing our CompatGMutex/CompatGCond - * by mistake to a function that expects GMutex/GCond. However, for ease - * of use we keep the GLib function names. GLib uses macros for the - * implementation, we use inline functions instead and undefine the macros. - */ - -typedef struct CompatGMutex { - GOnce once; -} CompatGMutex; - -typedef struct CompatGCond { - GOnce once; -} CompatGCond; - -static inline gpointer do_g_mutex_new(gpointer unused) -{ - return (gpointer) g_mutex_new(); -} - -static inline void g_mutex_init(CompatGMutex *mutex) -{ - mutex->once = (GOnce) G_ONCE_INIT; -} - -static inline void g_mutex_clear(CompatGMutex *mutex) -{ - assert(mutex->once.status != G_ONCE_STATUS_PROGRESS); - if (mutex->once.retval) { - g_mutex_free((GMutex *) mutex->once.retval); - } - mutex->once = (GOnce) G_ONCE_INIT; -} - -static inline void (g_mutex_lock)(CompatGMutex *mutex) -{ - g_once(&mutex->once, do_g_mutex_new, NULL); - g_mutex_lock((GMutex *) mutex->once.retval); -} -#undef g_mutex_lock - -static inline gboolean (g_mutex_trylock)(CompatGMutex *mutex) -{ - g_once(&mutex->once, do_g_mutex_new, NULL); - return g_mutex_trylock((GMutex *) mutex->once.retval); -} -#undef g_mutex_trylock - - -static inline void (g_mutex_unlock)(CompatGMutex *mutex) -{ - g_mutex_unlock((GMutex *) mutex->once.retval); -} -#undef g_mutex_unlock - -static inline gpointer do_g_cond_new(gpointer unused) -{ - return (gpointer) g_cond_new(); -} - -static inline void g_cond_init(CompatGCond *cond) -{ - cond->once = (GOnce) G_ONCE_INIT; -} - -static inline void g_cond_clear(CompatGCond *cond) -{ - assert(cond->once.status != G_ONCE_STATUS_PROGRESS); - if (cond->once.retval) { - g_cond_free((GCond *) cond->once.retval); - } - cond->once = (GOnce) G_ONCE_INIT; -} - -static inline void (g_cond_wait)(CompatGCond *cond, CompatGMutex *mutex) -{ - assert(mutex->once.status != G_ONCE_STATUS_PROGRESS); - g_once(&cond->once, do_g_cond_new, NULL); - g_cond_wait((GCond *) cond->once.retval, (GMutex *) mutex->once.retval); -} -#undef g_cond_wait - -static inline void (g_cond_broadcast)(CompatGCond *cond) -{ - g_once(&cond->once, do_g_cond_new, NULL); - g_cond_broadcast((GCond *) cond->once.retval); -} -#undef g_cond_broadcast - -static inline void (g_cond_signal)(CompatGCond *cond) -{ - g_once(&cond->once, do_g_cond_new, NULL); - g_cond_signal((GCond *) cond->once.retval); -} -#undef g_cond_signal - - -/* before 2.31 there was no g_thread_new() */ -static inline GThread *g_thread_new(const char *name, - GThreadFunc func, gpointer data) -{ - GThread *thread = g_thread_create(func, data, TRUE, NULL); - if (!thread) { - g_error("creating thread"); - } - return thread; -} -#else -#define CompatGMutex GMutex -#define CompatGCond GCond -#endif /* glib 2.31 */ - -#endif diff --git a/qemu/include/glib_compat.h b/qemu/include/glib_compat.h new file mode 100644 index 00000000..8adf06e7 --- /dev/null +++ b/qemu/include/glib_compat.h @@ -0,0 +1,135 @@ +/* +glib_compat.h replacement functionality for glib code used in qemu +Copyright (C) 2016 Chris Eagle cseagle at gmail dot com + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +*/ + +#ifndef __GLIB_COMPAT_H +#define __GLIB_COMPAT_H + +#include +#include +#include +#include + +#ifndef TRUE +#define TRUE 1 +#endif + +#ifndef FALSE +#define FALSE 1 +#endif + +#define g_assert(expr) assert(expr) +#define g_assert_not_reached() assert(0) + +/* typedefs for glib related types that may still be referenced */ +typedef void* gpointer; +typedef const void *gconstpointer; +typedef uint32_t guint; +typedef char gchar; +typedef int gboolean; + +typedef int (*GCompareFunc)(const void *v1, const void *v2); +typedef void (*GDestroyNotify)(void *data); + +uint32_t g_direct_hash(const void *v); +int g_direct_equal(const void *v1, const void *v2); +uint32_t g_str_hash(const void *v); +int g_str_equal(const void *v1, const void *v2); +uint32_t g_int_hash(const void *v); +int g_int_equal(const void *v1, const void *v2); + +typedef struct _GList { + void *data; + struct _GList *next; + struct _GList *prev; +} GList; + +typedef void (*list_func)(void* data, void* user_data); +typedef int (*compare_func)(const void *d1, const void *d2); + +GList *g_list_first(GList *list); +void g_list_foreach(GList *list, list_func func, void* user_data); +void g_list_free(GList *list); +GList *g_list_insert_sorted(GList *list, void* data, compare_func compare); +#define g_list_next(list) (list->next) +GList *g_list_prepend(GList *list, void* data); +GList *g_list_remove_link(GList *list, GList *llink); +GList *g_list_sort(GList *list, compare_func compare); + +typedef struct _GSList { + void *data; + struct _GSList *next; +} GSList; + +GSList *g_slist_append(GSList *list, void* data); +void g_slist_foreach(GSList *list, list_func func, void* user_data); +void g_slist_free(GSList *list); +void g_slist_free_full(GSList *list, GDestroyNotify free_func); +GSList *g_slist_prepend(GSList *list, void* data); +GSList *g_slist_sort(GSList *list, compare_func compare); +GSList *g_slist_find_custom(GSList *list, const void *data, compare_func func); +GSList *g_slist_remove(GSList *list, const void *data); + +typedef uint32_t (*GHashFunc)(const void *key); +typedef int (*GEqualFunc)(const void *a, const void *b); +typedef void (*GHFunc)(void* key, void* value, void* user_data); +typedef int (*GHRFunc)(void* key, void* value, void* user_data); + +typedef struct _GHashTable GHashTable; + +void g_hash_table_destroy(GHashTable *hash_table); +void* g_hash_table_find(GHashTable *hash_table, GHRFunc predicate, void* user_data); +void g_hash_table_foreach(GHashTable *hash_table, GHFunc func, void* user_data); +int g_hash_table_insert(GHashTable *hash_table, void* key, void* value); +void* g_hash_table_lookup(GHashTable *hash_table, const void* key); +GHashTable *g_hash_table_new(GHashFunc hash_func, GEqualFunc key_equal_func); +GHashTable *g_hash_table_new_full(GHashFunc hash_func, GEqualFunc key_equal_func, + GDestroyNotify key_destroy_func, GDestroyNotify value_destroy_func); +void g_hash_table_remove_all(GHashTable *hash_table); +int g_hash_table_remove(GHashTable *hash_table, const void* key); +void g_hash_table_unref(GHashTable *hash_table); +GHashTable *g_hash_table_ref(GHashTable *hash_table); +uint32_t g_hash_table_size(GHashTable *hash_table); + +/* replacement for g_malloc dependency */ +void *g_malloc(size_t size); +void *g_malloc0(size_t size); +void *g_try_malloc0(size_t size); +void *g_realloc(void *ptr, size_t size); +char *g_strdup(const char *str); +char *g_strdup_printf(const char *format, ...); +char *g_strdup_vprintf(const char *format, va_list ap); +char *g_strndup(const char *str, size_t n); +void g_strfreev(char **v); +void *g_memdup(const void *mem, size_t byte_size); +void *g_new_(size_t sz, size_t n_structs); +void *g_new0_(size_t sz, size_t n_structs); +void *g_renew_(size_t sz, void *mem, size_t n_structs); +char *g_strconcat(const char *string1, ...); + +char **g_strsplit(const char *string, const char *delimiter, int max_tokens); + +#define g_new(struct_type, n_structs) ((struct_type*)g_new_(sizeof(struct_type), n_structs)) +#define g_new0(struct_type, n_structs) ((struct_type*)g_new0_(sizeof(struct_type), n_structs)) +#define g_renew(struct_type, mem, n_structs) ((struct_type*)g_renew_(sizeof(struct_type), mem, n_structs)) + +#ifdef _WIN32 +char *g_win32_error_message(int error); +#endif + +#endif diff --git a/qemu/include/hw/arm/arm.h b/qemu/include/hw/arm/arm.h index 9e38953d..82bd5985 100644 --- a/qemu/include/hw/arm/arm.h +++ b/qemu/include/hw/arm/arm.h @@ -57,7 +57,7 @@ struct arm_boot_info { * sets get_dtb. This will only be used if no dtb file is provided * by the user. On success, sets *size to the length of the created * dtb, and returns a pointer to it. (The caller must free this memory - * with g_free() when it has finished with it.) On failure, returns NULL. + * with free() when it has finished with it.) On failure, returns NULL. */ void *(*get_dtb)(const struct arm_boot_info *info, int *size); /* if a board needs to be able to modify a device tree provided by diff --git a/qemu/include/qapi/string-output-visitor.h b/qemu/include/qapi/string-output-visitor.h deleted file mode 100644 index d99717f6..00000000 --- a/qemu/include/qapi/string-output-visitor.h +++ /dev/null @@ -1,26 +0,0 @@ -/* - * String printing Visitor - * - * Copyright Red Hat, Inc. 2012 - * - * Author: Paolo Bonzini - * - * This work is licensed under the terms of the GNU LGPL, version 2.1 or later. - * See the COPYING.LIB file in the top-level directory. - * - */ - -#ifndef STRING_OUTPUT_VISITOR_H -#define STRING_OUTPUT_VISITOR_H - -#include "qapi/visitor.h" - -typedef struct StringOutputVisitor StringOutputVisitor; - -StringOutputVisitor *string_output_visitor_new(bool human); -void string_output_visitor_cleanup(StringOutputVisitor *v); - -char *string_output_get_string(StringOutputVisitor *v); -Visitor *string_output_get_visitor(StringOutputVisitor *v); - -#endif diff --git a/qemu/include/qemu-common.h b/qemu/include/qemu-common.h index 665618ba..702501f5 100644 --- a/qemu/include/qemu-common.h +++ b/qemu/include/qemu-common.h @@ -41,7 +41,7 @@ #include #include #include -#include "glib-compat.h" +#include "glib_compat.h" #ifdef _WIN32 #include "sysemu/os-win32.h" diff --git a/qemu/include/qemu/bitmap.h b/qemu/include/qemu/bitmap.h index f0273c96..a3207f5e 100644 --- a/qemu/include/qemu/bitmap.h +++ b/qemu/include/qemu/bitmap.h @@ -12,7 +12,7 @@ #ifndef BITMAP_H #define BITMAP_H -#include +#include "glib_compat.h" #include #include diff --git a/qemu/include/qemu/osdep.h b/qemu/include/qemu/osdep.h index 9e4c7403..cc6aa396 100644 --- a/qemu/include/qemu/osdep.h +++ b/qemu/include/qemu/osdep.h @@ -209,19 +209,8 @@ const char *qemu_get_version(void); void fips_set_state(bool requested); bool fips_get_state(void); -/* Return a dynamically allocated pathname denoting a file or directory that is - * appropriate for storing local state. - * - * @relative_pathname need not start with a directory separator; one will be - * added automatically. - * - * The caller is responsible for releasing the value returned with g_free() - * after use. - */ -char *qemu_get_local_state_pathname(const char *relative_pathname); - /* Get the saved exec dir. - * Caller needs to release the returned string by g_free() */ + * Caller needs to release the returned string by free() */ char *qemu_get_exec_dir(void); /** diff --git a/qemu/include/qemu/range.h b/qemu/include/qemu/range.h index cfa021fd..b0953eee 100644 --- a/qemu/include/qemu/range.h +++ b/qemu/include/qemu/range.h @@ -119,7 +119,7 @@ static inline GList *g_list_insert_sorted_merged(GList *list, return list; } -static inline gint range_compare(gconstpointer a, gconstpointer b) +static inline int32_t range_compare(gconstpointer a, gconstpointer b) { Range *ra = (Range *)a, *rb = (Range *)b; if (ra->begin == rb->begin && ra->end == rb->end) { diff --git a/qemu/include/qemu/timer.h b/qemu/include/qemu/timer.h index 960455d8..02236453 100644 --- a/qemu/include/qemu/timer.h +++ b/qemu/include/qemu/timer.h @@ -574,19 +574,6 @@ void timer_put(QEMUFile *f, QEMUTimer *ts); */ int qemu_timeout_ns_to_ms(int64_t ns); -/** - * qemu_poll_ns: - * @fds: Array of file descriptors - * @nfds: number of file descriptors - * @timeout: timeout in nanoseconds - * - * Perform a poll like g_poll but with a timeout in nanoseconds. - * See g_poll documentation for further details. - * - * Returns: number of fds ready - */ -int qemu_poll_ns(GPollFD *fds, guint nfds, int64_t timeout); - /** * qemu_soonest_timeout: * @timeout1: first timeout in nanoseconds (or -1 for infinite) diff --git a/qemu/include/qom/object.h b/qemu/include/qom/object.h index 9aa312c1..c539b422 100644 --- a/qemu/include/qom/object.h +++ b/qemu/include/qom/object.h @@ -14,7 +14,7 @@ #ifndef QEMU_OBJECT_H #define QEMU_OBJECT_H -#include +#include "glib_compat.h" #include #include #include "qemu/queue.h" @@ -932,34 +932,6 @@ void object_property_set_int(struct uc_struct *uc, Object *obj, int64_t value, int64_t object_property_get_int(struct uc_struct *uc, Object *obj, const char *name, Error **errp); -/** - * object_property_get_enum: - * @obj: the object - * @name: the name of the property - * @strings: strings corresponding to enums - * @errp: returns an error if this function fails - * - * Returns: the value of the property, converted to an integer, or - * undefined if an error occurs (including when the property value is not - * an enum). - */ -int object_property_get_enum(struct uc_struct *uc, Object *obj, const char *name, - const char *strings[], Error **errp); - -/** - * object_property_get_uint16List: - * @obj: the object - * @name: the name of the property - * @list: the returned int list - * @errp: returns an error if this function fails - * - * Returns: the value of the property, converted to integers, or - * undefined if an error occurs (including when the property value is not - * an list of integers). - */ -void object_property_get_uint16List(struct uc_struct *uc, Object *obj, const char *name, - uint16List **list, Error **errp); - /** * object_property_set: * @obj: the object @@ -986,19 +958,6 @@ void object_property_set(struct uc_struct *uc, Object *obj, struct Visitor *v, c void object_property_parse(struct uc_struct *uc, Object *obj, const char *string, const char *name, Error **errp); -/** - * object_property_print: - * @obj: the object - * @name: the name of the property - * @human: if true, print for human consumption - * @errp: returns an error if this function fails - * - * Returns a string representation of the value of the property. The - * caller shall free the string. - */ -char *object_property_print(struct uc_struct *uc, Object *obj, const char *name, bool human, - Error **errp); - /** * object_property_get_type: * @obj: the object @@ -1166,7 +1125,7 @@ void object_property_add_link(Object *obj, const char *name, * @obj: the object to add a property to * @name: the name of the property * @get: the getter or NULL if the property is write-only. This function must - * return a string to be freed by g_free(). + * return a string to be freed by free(). * @set: the setter or NULL if the property is read-only * @errp: if an error occurs, a pointer to an area to store the error * diff --git a/qemu/m68k.h b/qemu/m68k.h index 5b94d6bc..24e2e737 100644 --- a/qemu/m68k.h +++ b/qemu/m68k.h @@ -2179,15 +2179,12 @@ #define object_property_find object_property_find_m68k #define object_property_get object_property_get_m68k #define object_property_get_bool object_property_get_bool_m68k -#define object_property_get_enum object_property_get_enum_m68k #define object_property_get_int object_property_get_int_m68k #define object_property_get_link object_property_get_link_m68k #define object_property_get_qobject object_property_get_qobject_m68k #define object_property_get_str object_property_get_str_m68k #define object_property_get_type object_property_get_type_m68k -#define object_property_get_uint16List object_property_get_uint16List_m68k #define object_property_is_child object_property_is_child_m68k -#define object_property_print object_property_print_m68k #define object_property_set object_property_set_m68k #define object_property_set_description object_property_set_description_m68k #define object_property_set_link object_property_set_link_m68k @@ -2427,7 +2424,6 @@ #define qemu_get_cpu qemu_get_cpu_m68k #define qemu_get_guest_memory_mapping qemu_get_guest_memory_mapping_m68k #define qemu_get_guest_simple_memory_mapping qemu_get_guest_simple_memory_mapping_m68k -#define qemu_get_local_state_pathname qemu_get_local_state_pathname_m68k #define qemu_get_ram_block qemu_get_ram_block_m68k #define qemu_get_ram_block_host_ptr qemu_get_ram_block_host_ptr_m68k #define qemu_get_ram_fd qemu_get_ram_fd_m68k @@ -2716,13 +2712,6 @@ #define string_input_get_visitor string_input_get_visitor_m68k #define string_input_visitor_cleanup string_input_visitor_cleanup_m68k #define string_input_visitor_new string_input_visitor_new_m68k -#define string_output_append string_output_append_m68k -#define string_output_append_range string_output_append_range_m68k -#define string_output_get_string string_output_get_string_m68k -#define string_output_get_visitor string_output_get_visitor_m68k -#define string_output_set string_output_set_m68k -#define string_output_visitor_cleanup string_output_visitor_cleanup_m68k -#define string_output_visitor_new string_output_visitor_new_m68k #define stristart stristart_m68k #define strongarm_cp_reginfo strongarm_cp_reginfo_m68k #define strpadcpy strpadcpy_m68k diff --git a/qemu/memory.c b/qemu/memory.c index 453ddce1..baf6b697 100644 --- a/qemu/memory.c +++ b/qemu/memory.c @@ -91,9 +91,9 @@ void memory_unmap(struct uc_struct *uc, MemoryRegion *mr) mr->destructor(mr); obj = OBJECT(mr); obj->ref = 1; - obj->free = g_free; - g_free(mr->ioeventfds); - g_free((char *)mr->name); + obj->free = free; + free(mr->ioeventfds); + free((char *)mr->name); mr->name = NULL; object_property_del_child(mr->uc, qdev_get_machine(mr->uc), obj, &error_abort); break; @@ -114,8 +114,8 @@ int memory_free(struct uc_struct *uc) mr->destructor(mr); obj = OBJECT(mr); obj->ref = 1; - obj->free = g_free; - g_free(mr->ioeventfds); + obj->free = free; + free(mr->ioeventfds); object_property_del_child(mr->uc, qdev_get_machine(mr->uc), obj, &error_abort); } @@ -375,8 +375,8 @@ static void flatview_destroy(FlatView *view) for (i = 0; i < view->nr; i++) { memory_region_unref(view->ranges[i].mr); } - g_free(view->ranges); - g_free(view); + free(view->ranges); + free(view); } static void flatview_ref(FlatView *view) @@ -767,7 +767,7 @@ static void address_space_update_ioeventfds(AddressSpace *as) address_space_add_del_ioeventfds(as, ioeventfds, ioeventfd_nb, as->ioeventfds, as->ioeventfd_nb); - g_free(as->ioeventfds); + free(as->ioeventfds); as->ioeventfds = ioeventfds; as->ioeventfd_nb = ioeventfd_nb; flatview_unref(view); @@ -973,8 +973,8 @@ void memory_region_init(struct uc_struct *uc, MemoryRegion *mr, char *name_array = g_strdup_printf("%s[*]", escaped_name); object_property_add_child(owner, name_array, OBJECT(mr), &error_abort); object_unref(uc, OBJECT(mr)); - g_free(name_array); - g_free(escaped_name); + free(name_array); + free(escaped_name); } } @@ -998,7 +998,7 @@ static void memory_region_get_container(struct uc_struct *uc, Object *obj, Visit } visit_type_str(v, &path, name, errp); if (mr->container) { - g_free(path); + free(path); } } @@ -1283,8 +1283,8 @@ static void memory_region_finalize(struct uc_struct *uc, Object *obj, void *opaq // assert(memory_region_transaction_depth == 0); mr->destructor(mr); memory_region_clear_coalescing(mr); - g_free((char *)mr->name); - g_free(mr->ioeventfds); + free((char *)mr->name); + free(mr->ioeventfds); } void memory_region_ref(MemoryRegion *mr) @@ -1482,7 +1482,7 @@ void memory_region_clear_coalescing(MemoryRegion *mr) while (!QTAILQ_EMPTY(&mr->coalesced)) { cmr = QTAILQ_FIRST(&mr->coalesced); QTAILQ_REMOVE(&mr->coalesced, cmr, link); - g_free(cmr); + free(cmr); updated = true; } @@ -1883,8 +1883,8 @@ void address_space_destroy(AddressSpace *as) } flatview_unref(as->current_map); - g_free(as->name); - g_free(as->ioeventfds); + free(as->name); + free(as->ioeventfds); } bool io_mem_read(MemoryRegion *mr, hwaddr addr, uint64_t *pval, unsigned size) diff --git a/qemu/memory_mapping.c b/qemu/memory_mapping.c index 7295d360..88168ade 100644 --- a/qemu/memory_mapping.c +++ b/qemu/memory_mapping.c @@ -13,7 +13,7 @@ /* Modified for Unicorn Engine by Nguyen Anh Quynh, 2015 */ -#include +#include "glib_compat.h" #include "cpu.h" #include "exec/cpu-all.h" @@ -161,7 +161,7 @@ void memory_mapping_list_free(MemoryMappingList *list) QTAILQ_FOREACH_SAFE(p, &list->head, next, q) { QTAILQ_REMOVE(&list->head, p, next); - g_free(p); + free(p); } list->num = 0; @@ -181,7 +181,7 @@ void guest_phys_blocks_free(GuestPhysBlockList *list) QTAILQ_FOREACH_SAFE(p, &list->head, next, q) { QTAILQ_REMOVE(&list->head, p, next); - g_free(p); + free(p); } list->num = 0; } diff --git a/qemu/mips.h b/qemu/mips.h index 42abe8e1..5913685c 100644 --- a/qemu/mips.h +++ b/qemu/mips.h @@ -2179,15 +2179,12 @@ #define object_property_find object_property_find_mips #define object_property_get object_property_get_mips #define object_property_get_bool object_property_get_bool_mips -#define object_property_get_enum object_property_get_enum_mips #define object_property_get_int object_property_get_int_mips #define object_property_get_link object_property_get_link_mips #define object_property_get_qobject object_property_get_qobject_mips #define object_property_get_str object_property_get_str_mips #define object_property_get_type object_property_get_type_mips -#define object_property_get_uint16List object_property_get_uint16List_mips #define object_property_is_child object_property_is_child_mips -#define object_property_print object_property_print_mips #define object_property_set object_property_set_mips #define object_property_set_description object_property_set_description_mips #define object_property_set_link object_property_set_link_mips @@ -2427,7 +2424,6 @@ #define qemu_get_cpu qemu_get_cpu_mips #define qemu_get_guest_memory_mapping qemu_get_guest_memory_mapping_mips #define qemu_get_guest_simple_memory_mapping qemu_get_guest_simple_memory_mapping_mips -#define qemu_get_local_state_pathname qemu_get_local_state_pathname_mips #define qemu_get_ram_block qemu_get_ram_block_mips #define qemu_get_ram_block_host_ptr qemu_get_ram_block_host_ptr_mips #define qemu_get_ram_fd qemu_get_ram_fd_mips @@ -2716,13 +2712,6 @@ #define string_input_get_visitor string_input_get_visitor_mips #define string_input_visitor_cleanup string_input_visitor_cleanup_mips #define string_input_visitor_new string_input_visitor_new_mips -#define string_output_append string_output_append_mips -#define string_output_append_range string_output_append_range_mips -#define string_output_get_string string_output_get_string_mips -#define string_output_get_visitor string_output_get_visitor_mips -#define string_output_set string_output_set_mips -#define string_output_visitor_cleanup string_output_visitor_cleanup_mips -#define string_output_visitor_new string_output_visitor_new_mips #define stristart stristart_mips #define strongarm_cp_reginfo strongarm_cp_reginfo_mips #define strpadcpy strpadcpy_mips diff --git a/qemu/mips64.h b/qemu/mips64.h index de543305..0348d4b6 100644 --- a/qemu/mips64.h +++ b/qemu/mips64.h @@ -2179,15 +2179,12 @@ #define object_property_find object_property_find_mips64 #define object_property_get object_property_get_mips64 #define object_property_get_bool object_property_get_bool_mips64 -#define object_property_get_enum object_property_get_enum_mips64 #define object_property_get_int object_property_get_int_mips64 #define object_property_get_link object_property_get_link_mips64 #define object_property_get_qobject object_property_get_qobject_mips64 #define object_property_get_str object_property_get_str_mips64 #define object_property_get_type object_property_get_type_mips64 -#define object_property_get_uint16List object_property_get_uint16List_mips64 #define object_property_is_child object_property_is_child_mips64 -#define object_property_print object_property_print_mips64 #define object_property_set object_property_set_mips64 #define object_property_set_description object_property_set_description_mips64 #define object_property_set_link object_property_set_link_mips64 @@ -2427,7 +2424,6 @@ #define qemu_get_cpu qemu_get_cpu_mips64 #define qemu_get_guest_memory_mapping qemu_get_guest_memory_mapping_mips64 #define qemu_get_guest_simple_memory_mapping qemu_get_guest_simple_memory_mapping_mips64 -#define qemu_get_local_state_pathname qemu_get_local_state_pathname_mips64 #define qemu_get_ram_block qemu_get_ram_block_mips64 #define qemu_get_ram_block_host_ptr qemu_get_ram_block_host_ptr_mips64 #define qemu_get_ram_fd qemu_get_ram_fd_mips64 @@ -2716,13 +2712,6 @@ #define string_input_get_visitor string_input_get_visitor_mips64 #define string_input_visitor_cleanup string_input_visitor_cleanup_mips64 #define string_input_visitor_new string_input_visitor_new_mips64 -#define string_output_append string_output_append_mips64 -#define string_output_append_range string_output_append_range_mips64 -#define string_output_get_string string_output_get_string_mips64 -#define string_output_get_visitor string_output_get_visitor_mips64 -#define string_output_set string_output_set_mips64 -#define string_output_visitor_cleanup string_output_visitor_cleanup_mips64 -#define string_output_visitor_new string_output_visitor_new_mips64 #define stristart stristart_mips64 #define strongarm_cp_reginfo strongarm_cp_reginfo_mips64 #define strpadcpy strpadcpy_mips64 diff --git a/qemu/mips64el.h b/qemu/mips64el.h index e4373fed..7ad248a8 100644 --- a/qemu/mips64el.h +++ b/qemu/mips64el.h @@ -2179,15 +2179,12 @@ #define object_property_find object_property_find_mips64el #define object_property_get object_property_get_mips64el #define object_property_get_bool object_property_get_bool_mips64el -#define object_property_get_enum object_property_get_enum_mips64el #define object_property_get_int object_property_get_int_mips64el #define object_property_get_link object_property_get_link_mips64el #define object_property_get_qobject object_property_get_qobject_mips64el #define object_property_get_str object_property_get_str_mips64el #define object_property_get_type object_property_get_type_mips64el -#define object_property_get_uint16List object_property_get_uint16List_mips64el #define object_property_is_child object_property_is_child_mips64el -#define object_property_print object_property_print_mips64el #define object_property_set object_property_set_mips64el #define object_property_set_description object_property_set_description_mips64el #define object_property_set_link object_property_set_link_mips64el @@ -2427,7 +2424,6 @@ #define qemu_get_cpu qemu_get_cpu_mips64el #define qemu_get_guest_memory_mapping qemu_get_guest_memory_mapping_mips64el #define qemu_get_guest_simple_memory_mapping qemu_get_guest_simple_memory_mapping_mips64el -#define qemu_get_local_state_pathname qemu_get_local_state_pathname_mips64el #define qemu_get_ram_block qemu_get_ram_block_mips64el #define qemu_get_ram_block_host_ptr qemu_get_ram_block_host_ptr_mips64el #define qemu_get_ram_fd qemu_get_ram_fd_mips64el @@ -2716,13 +2712,6 @@ #define string_input_get_visitor string_input_get_visitor_mips64el #define string_input_visitor_cleanup string_input_visitor_cleanup_mips64el #define string_input_visitor_new string_input_visitor_new_mips64el -#define string_output_append string_output_append_mips64el -#define string_output_append_range string_output_append_range_mips64el -#define string_output_get_string string_output_get_string_mips64el -#define string_output_get_visitor string_output_get_visitor_mips64el -#define string_output_set string_output_set_mips64el -#define string_output_visitor_cleanup string_output_visitor_cleanup_mips64el -#define string_output_visitor_new string_output_visitor_new_mips64el #define stristart stristart_mips64el #define strongarm_cp_reginfo strongarm_cp_reginfo_mips64el #define strpadcpy strpadcpy_mips64el diff --git a/qemu/mipsel.h b/qemu/mipsel.h index 434c1194..c9ad269e 100644 --- a/qemu/mipsel.h +++ b/qemu/mipsel.h @@ -2179,15 +2179,12 @@ #define object_property_find object_property_find_mipsel #define object_property_get object_property_get_mipsel #define object_property_get_bool object_property_get_bool_mipsel -#define object_property_get_enum object_property_get_enum_mipsel #define object_property_get_int object_property_get_int_mipsel #define object_property_get_link object_property_get_link_mipsel #define object_property_get_qobject object_property_get_qobject_mipsel #define object_property_get_str object_property_get_str_mipsel #define object_property_get_type object_property_get_type_mipsel -#define object_property_get_uint16List object_property_get_uint16List_mipsel #define object_property_is_child object_property_is_child_mipsel -#define object_property_print object_property_print_mipsel #define object_property_set object_property_set_mipsel #define object_property_set_description object_property_set_description_mipsel #define object_property_set_link object_property_set_link_mipsel @@ -2427,7 +2424,6 @@ #define qemu_get_cpu qemu_get_cpu_mipsel #define qemu_get_guest_memory_mapping qemu_get_guest_memory_mapping_mipsel #define qemu_get_guest_simple_memory_mapping qemu_get_guest_simple_memory_mapping_mipsel -#define qemu_get_local_state_pathname qemu_get_local_state_pathname_mipsel #define qemu_get_ram_block qemu_get_ram_block_mipsel #define qemu_get_ram_block_host_ptr qemu_get_ram_block_host_ptr_mipsel #define qemu_get_ram_fd qemu_get_ram_fd_mipsel @@ -2716,13 +2712,6 @@ #define string_input_get_visitor string_input_get_visitor_mipsel #define string_input_visitor_cleanup string_input_visitor_cleanup_mipsel #define string_input_visitor_new string_input_visitor_new_mipsel -#define string_output_append string_output_append_mipsel -#define string_output_append_range string_output_append_range_mipsel -#define string_output_get_string string_output_get_string_mipsel -#define string_output_get_visitor string_output_get_visitor_mipsel -#define string_output_set string_output_set_mipsel -#define string_output_visitor_cleanup string_output_visitor_cleanup_mipsel -#define string_output_visitor_new string_output_visitor_new_mipsel #define stristart stristart_mipsel #define strongarm_cp_reginfo strongarm_cp_reginfo_mipsel #define strpadcpy strpadcpy_mipsel diff --git a/qemu/powerpc.h b/qemu/powerpc.h index d778f297..2a63de7b 100644 --- a/qemu/powerpc.h +++ b/qemu/powerpc.h @@ -2179,15 +2179,12 @@ #define object_property_find object_property_find_powerpc #define object_property_get object_property_get_powerpc #define object_property_get_bool object_property_get_bool_powerpc -#define object_property_get_enum object_property_get_enum_powerpc #define object_property_get_int object_property_get_int_powerpc #define object_property_get_link object_property_get_link_powerpc #define object_property_get_qobject object_property_get_qobject_powerpc #define object_property_get_str object_property_get_str_powerpc #define object_property_get_type object_property_get_type_powerpc -#define object_property_get_uint16List object_property_get_uint16List_powerpc #define object_property_is_child object_property_is_child_powerpc -#define object_property_print object_property_print_powerpc #define object_property_set object_property_set_powerpc #define object_property_set_description object_property_set_description_powerpc #define object_property_set_link object_property_set_link_powerpc @@ -2427,7 +2424,6 @@ #define qemu_get_cpu qemu_get_cpu_powerpc #define qemu_get_guest_memory_mapping qemu_get_guest_memory_mapping_powerpc #define qemu_get_guest_simple_memory_mapping qemu_get_guest_simple_memory_mapping_powerpc -#define qemu_get_local_state_pathname qemu_get_local_state_pathname_powerpc #define qemu_get_ram_block qemu_get_ram_block_powerpc #define qemu_get_ram_block_host_ptr qemu_get_ram_block_host_ptr_powerpc #define qemu_get_ram_fd qemu_get_ram_fd_powerpc @@ -2716,13 +2712,6 @@ #define string_input_get_visitor string_input_get_visitor_powerpc #define string_input_visitor_cleanup string_input_visitor_cleanup_powerpc #define string_input_visitor_new string_input_visitor_new_powerpc -#define string_output_append string_output_append_powerpc -#define string_output_append_range string_output_append_range_powerpc -#define string_output_get_string string_output_get_string_powerpc -#define string_output_get_visitor string_output_get_visitor_powerpc -#define string_output_set string_output_set_powerpc -#define string_output_visitor_cleanup string_output_visitor_cleanup_powerpc -#define string_output_visitor_new string_output_visitor_new_powerpc #define stristart stristart_powerpc #define strongarm_cp_reginfo strongarm_cp_reginfo_powerpc #define strpadcpy strpadcpy_powerpc diff --git a/qemu/qapi/Makefile.objs b/qemu/qapi/Makefile.objs index 06ca0eb6..00e40d60 100644 --- a/qemu/qapi/Makefile.objs +++ b/qemu/qapi/Makefile.objs @@ -1,3 +1,3 @@ util-obj-y = qapi-visit-core.o qapi-dealloc-visitor.o qmp-input-visitor.o util-obj-y += qmp-output-visitor.o -util-obj-y += string-input-visitor.o string-output-visitor.o +util-obj-y += string-input-visitor.o diff --git a/qemu/qapi/qapi-dealloc-visitor.c b/qemu/qapi/qapi-dealloc-visitor.c index a14a1c71..19d2944c 100644 --- a/qemu/qapi/qapi-dealloc-visitor.c +++ b/qemu/qapi/qapi-dealloc-visitor.c @@ -55,7 +55,7 @@ static void *qapi_dealloc_pop(QapiDeallocVisitor *qov) QObject *value; QTAILQ_REMOVE(&qov->stack, e, node); value = e->value; - g_free(e); + free(e); return value; } @@ -72,7 +72,7 @@ static void qapi_dealloc_end_struct(Visitor *v, Error **errp) QapiDeallocVisitor *qov = to_qov(v); void **obj = qapi_dealloc_pop(qov); if (obj) { - g_free(*obj); + free(*obj); } } @@ -90,7 +90,7 @@ static void qapi_dealloc_end_implicit_struct(Visitor *v, Error **errp) QapiDeallocVisitor *qov = to_qov(v); void **obj = qapi_dealloc_pop(qov); if (obj) { - g_free(*obj); + free(*obj); } } @@ -114,7 +114,7 @@ static GenericList *qapi_dealloc_next_list(Visitor *v, GenericList **listp, if (list) { list = list->next; - g_free(*listp); + free(*listp); return list; } @@ -132,7 +132,7 @@ static void qapi_dealloc_type_str(Visitor *v, char **obj, const char *name, Error **errp) { if (obj) { - g_free(*obj); + free(*obj); } } @@ -194,7 +194,7 @@ Visitor *qapi_dealloc_get_visitor(QapiDeallocVisitor *v) void qapi_dealloc_visitor_cleanup(QapiDeallocVisitor *v) { - g_free(v); + free(v); } QapiDeallocVisitor *qapi_dealloc_visitor_new(void) diff --git a/qemu/qapi/qapi-visit-core.c b/qemu/qapi/qapi-visit-core.c index b66b93ae..ff5f8b9f 100644 --- a/qemu/qapi/qapi-visit-core.c +++ b/qemu/qapi/qapi-visit-core.c @@ -304,10 +304,10 @@ void input_type_enum(Visitor *v, int *obj, const char *strings[], if (strings[value] == NULL) { error_set(errp, QERR_INVALID_PARAMETER, enum_str); - g_free(enum_str); + free(enum_str); return; } - g_free(enum_str); + free(enum_str); *obj = value; } diff --git a/qemu/qapi/qmp-input-visitor.c b/qemu/qapi/qmp-input-visitor.c index d8612062..564134b9 100644 --- a/qemu/qapi/qmp-input-visitor.c +++ b/qemu/qapi/qmp-input-visitor.c @@ -308,7 +308,7 @@ Visitor *qmp_input_get_visitor(QmpInputVisitor *v) void qmp_input_visitor_cleanup(QmpInputVisitor *v) { qobject_decref(v->stack[0].obj); - g_free(v); + free(v); } QmpInputVisitor *qmp_input_visitor_new(QObject *obj) diff --git a/qemu/qapi/qmp-output-visitor.c b/qemu/qapi/qmp-output-visitor.c index 96b33846..9e54cbe3 100644 --- a/qemu/qapi/qmp-output-visitor.c +++ b/qemu/qapi/qmp-output-visitor.c @@ -59,7 +59,7 @@ static QObject *qmp_output_pop(QmpOutputVisitor *qov) QObject *value; QTAILQ_REMOVE(&qov->stack, e, node); value = e->value; - g_free(e); + free(e); return value; } @@ -211,11 +211,11 @@ void qmp_output_visitor_cleanup(QmpOutputVisitor *v) QTAILQ_FOREACH_SAFE(e, &v->stack, node, tmp) { QTAILQ_REMOVE(&v->stack, e, node); - g_free(e); + free(e); } qobject_decref(root); - g_free(v); + free(v); } QmpOutputVisitor *qmp_output_visitor_new(void) diff --git a/qemu/qapi/string-input-visitor.c b/qemu/qapi/string-input-visitor.c index d8a8db02..de1b26d8 100644 --- a/qemu/qapi/string-input-visitor.c +++ b/qemu/qapi/string-input-visitor.c @@ -34,7 +34,7 @@ struct StringInputVisitor static void free_range(void *range, void *dummy) { - g_free(range); + free(range); } static void parse_str(StringInputVisitor *siv, Error **errp) @@ -321,7 +321,7 @@ void string_input_visitor_cleanup(StringInputVisitor *v) { g_list_foreach(v->ranges, free_range, NULL); g_list_free(v->ranges); - g_free(v); + free(v); } StringInputVisitor *string_input_visitor_new(const char *str) diff --git a/qemu/qapi/string-output-visitor.c b/qemu/qapi/string-output-visitor.c deleted file mode 100644 index 1ab85745..00000000 --- a/qemu/qapi/string-output-visitor.c +++ /dev/null @@ -1,354 +0,0 @@ -/* - * String printing Visitor - * - * Copyright Red Hat, Inc. 2012 - * - * Author: Paolo Bonzini - * - * This work is licensed under the terms of the GNU LGPL, version 2.1 or later. - * See the COPYING.LIB file in the top-level directory. - * - */ - -#include "qemu-common.h" -#include "qapi/string-output-visitor.h" -#include "qapi/visitor-impl.h" -#include "qapi/qmp/qerror.h" -#include "qemu/host-utils.h" -#include -#include "qemu/range.h" - -enum ListMode { - LM_NONE, /* not traversing a list of repeated options */ - LM_STARTED, /* start_list() succeeded */ - - LM_IN_PROGRESS, /* next_list() has been called. - * - * Generating the next list link will consume the most - * recently parsed QemuOpt instance of the repeated - * option. - * - * Parsing a value into the list link will examine the - * next QemuOpt instance of the repeated option, and - * possibly enter LM_SIGNED_INTERVAL or - * LM_UNSIGNED_INTERVAL. - */ - - LM_SIGNED_INTERVAL, /* next_list() has been called. - * - * Generating the next list link will consume the most - * recently stored element from the signed interval, - * parsed from the most recent QemuOpt instance of the - * repeated option. This may consume QemuOpt itself - * and return to LM_IN_PROGRESS. - * - * Parsing a value into the list link will store the - * next element of the signed interval. - */ - - LM_UNSIGNED_INTERVAL,/* Same as above, only for an unsigned interval. */ - - LM_END -}; - -typedef enum ListMode ListMode; - -struct StringOutputVisitor -{ - Visitor visitor; - bool human; - GString *string; - bool head; - ListMode list_mode; - union { - int64_t s; - uint64_t u; - } range_start, range_end; - GList *ranges; -}; - -static void string_output_set(StringOutputVisitor *sov, char *string) -{ - if (sov->string) { - g_string_free(sov->string, true); - } - sov->string = g_string_new(string); - g_free(string); -} - -static void string_output_append(StringOutputVisitor *sov, int64_t a) -{ - Range *r = g_malloc0(sizeof(*r)); - r->begin = a; - r->end = a + 1; - sov->ranges = g_list_insert_sorted_merged(sov->ranges, r, range_compare); -} - -static void string_output_append_range(StringOutputVisitor *sov, - int64_t s, int64_t e) -{ - Range *r = g_malloc0(sizeof(*r)); - r->begin = s; - r->end = e + 1; - sov->ranges = g_list_insert_sorted_merged(sov->ranges, r, range_compare); -} - -static void format_string(StringOutputVisitor *sov, Range *r, bool next, - bool human) -{ - if (r->end - r->begin > 1) { - if (human) { - g_string_append_printf(sov->string, "0x%" PRIx64 "-0x%" PRIx64, - r->begin, r->end - 1); - - } else { - g_string_append_printf(sov->string, "%" PRId64 "-%" PRId64, - r->begin, r->end - 1); - } - } else { - if (human) { - g_string_append_printf(sov->string, "0x%" PRIx64, r->begin); - } else { - g_string_append_printf(sov->string, "%" PRId64, r->begin); - } - } - if (next) { - g_string_append(sov->string, ","); - } -} - -static void print_type_int(Visitor *v, int64_t *obj, const char *name, - Error **errp) -{ - StringOutputVisitor *sov = DO_UPCAST(StringOutputVisitor, visitor, v); - GList *l; - - switch (sov->list_mode) { - case LM_NONE: - string_output_append(sov, *obj); - break; - - case LM_STARTED: - sov->range_start.s = *obj; - sov->range_end.s = *obj; - sov->list_mode = LM_IN_PROGRESS; - return; - - case LM_IN_PROGRESS: - if (sov->range_end.s + 1 == *obj) { - sov->range_end.s++; - } else { - if (sov->range_start.s == sov->range_end.s) { - string_output_append(sov, sov->range_end.s); - } else { - assert(sov->range_start.s < sov->range_end.s); - string_output_append_range(sov, sov->range_start.s, - sov->range_end.s); - } - - sov->range_start.s = *obj; - sov->range_end.s = *obj; - } - return; - - case LM_END: - if (sov->range_end.s + 1 == *obj) { - sov->range_end.s++; - assert(sov->range_start.s < sov->range_end.s); - string_output_append_range(sov, sov->range_start.s, - sov->range_end.s); - } else { - if (sov->range_start.s == sov->range_end.s) { - string_output_append(sov, sov->range_end.s); - } else { - assert(sov->range_start.s < sov->range_end.s); - - string_output_append_range(sov, sov->range_start.s, - sov->range_end.s); - } - string_output_append(sov, *obj); - } - break; - - default: - abort(); - } - - l = sov->ranges; - while (l) { - Range *r = l->data; - format_string(sov, r, l->next != NULL, false); - l = l->next; - } - - if (sov->human) { - l = sov->ranges; - g_string_append(sov->string, " ("); - while (l) { - Range *r = l->data; - format_string(sov, r, l->next != NULL, true); - l = l->next; - } - g_string_append(sov->string, ")"); - } -} - -static void print_type_size(Visitor *v, uint64_t *obj, const char *name, - Error **errp) -{ - StringOutputVisitor *sov = DO_UPCAST(StringOutputVisitor, visitor, v); - static const char suffixes[] = { 'B', 'K', 'M', 'G', 'T', 'P', 'E' }; - uint64_t div, val; - char *out; - int i; - - if (!sov->human) { - out = g_strdup_printf("%"PRIu64, *obj); - string_output_set(sov, out); - return; - } - - val = *obj; - - /* The exponent (returned in i) minus one gives us - * floor(log2(val * 1024 / 1000). The correction makes us - * switch to the higher power when the integer part is >= 1000. - */ - frexp(val / (1000.0 / 1024.0), &i); - i = (i - 1) / 10; - assert(i < ARRAY_SIZE(suffixes)); - div = 1ULL << (i * 10); - - out = g_strdup_printf("%"PRIu64" (%0.3g %c%s)", val, - (double)val/div, suffixes[i], i ? "iB" : ""); - string_output_set(sov, out); -} - -static void print_type_bool(Visitor *v, bool *obj, const char *name, - Error **errp) -{ - StringOutputVisitor *sov = DO_UPCAST(StringOutputVisitor, visitor, v); - string_output_set(sov, g_strdup(*obj ? "true" : "false")); -} - -static void print_type_str(Visitor *v, char **obj, const char *name, - Error **errp) -{ - StringOutputVisitor *sov = DO_UPCAST(StringOutputVisitor, visitor, v); - char *out; - - if (sov->human) { - out = *obj ? g_strdup_printf("\"%s\"", *obj) : g_strdup(""); - } else { - out = g_strdup(*obj ? *obj : ""); - } - string_output_set(sov, out); -} - -static void print_type_number(Visitor *v, double *obj, const char *name, - Error **errp) -{ - StringOutputVisitor *sov = DO_UPCAST(StringOutputVisitor, visitor, v); - string_output_set(sov, g_strdup_printf("%f", *obj)); -} - -static void -start_list(Visitor *v, const char *name, Error **errp) -{ - StringOutputVisitor *sov = DO_UPCAST(StringOutputVisitor, visitor, v); - - /* we can't traverse a list in a list */ - assert(sov->list_mode == LM_NONE); - sov->list_mode = LM_STARTED; - sov->head = true; -} - -static GenericList * -next_list(Visitor *v, GenericList **list, Error **errp) -{ - StringOutputVisitor *sov = DO_UPCAST(StringOutputVisitor, visitor, v); - GenericList *ret = NULL; - if (*list) { - if (sov->head) { - ret = *list; - } else { - ret = (*list)->next; - } - - if (sov->head) { - if (ret && ret->next == NULL) { - sov->list_mode = LM_NONE; - } - sov->head = false; - } else { - if (ret && ret->next == NULL) { - sov->list_mode = LM_END; - } - } - } - - return ret; -} - -static void -end_list(Visitor *v, Error **errp) -{ - StringOutputVisitor *sov = DO_UPCAST(StringOutputVisitor, visitor, v); - - assert(sov->list_mode == LM_STARTED || - sov->list_mode == LM_END || - sov->list_mode == LM_NONE || - sov->list_mode == LM_IN_PROGRESS); - sov->list_mode = LM_NONE; - sov->head = true; - -} - -char *string_output_get_string(StringOutputVisitor *sov) -{ - char *string = g_string_free(sov->string, false); - sov->string = NULL; - return string; -} - -Visitor *string_output_get_visitor(StringOutputVisitor *sov) -{ - return &sov->visitor; -} - -static void free_range(void *range, void *dummy) -{ - g_free(range); -} - -void string_output_visitor_cleanup(StringOutputVisitor *sov) -{ - if (sov->string) { - g_string_free(sov->string, true); - } - - g_list_foreach(sov->ranges, free_range, NULL); - g_list_free(sov->ranges); - g_free(sov); -} - -StringOutputVisitor *string_output_visitor_new(bool human) -{ - StringOutputVisitor *v; - - v = g_malloc0(sizeof(*v)); - - v->string = g_string_new(NULL); - v->human = human; - v->visitor.type_enum = output_type_enum; - v->visitor.type_int = print_type_int; - v->visitor.type_size = print_type_size; - v->visitor.type_bool = print_type_bool; - v->visitor.type_str = print_type_str; - v->visitor.type_number = print_type_number; - v->visitor.start_list = start_list; - v->visitor.next_list = next_list; - v->visitor.end_list = end_list; - - return v; -} diff --git a/qemu/qemu-timer.c b/qemu/qemu-timer.c index a4e8eb17..26c6f01d 100644 --- a/qemu/qemu-timer.c +++ b/qemu/qemu-timer.c @@ -103,7 +103,7 @@ void timerlist_free(QEMUTimerList *timer_list) QLIST_REMOVE(timer_list, list); } qemu_mutex_destroy(&timer_list->active_timers_lock); - g_free(timer_list); + free(timer_list); } bool timerlist_has_timers(QEMUTimerList *timer_list) diff --git a/qemu/qobject/json-parser.c b/qemu/qobject/json-parser.c index 4288267b..7273b290 100644 --- a/qemu/qobject/json-parser.c +++ b/qemu/qobject/json-parser.c @@ -354,8 +354,8 @@ static void parser_context_free(JSONParserContext *ctxt) for (i = 0; i < ctxt->tokens.count; i++) { qobject_decref(ctxt->tokens.buf[i]); } - g_free(ctxt->tokens.buf); - g_free(ctxt); + free(ctxt->tokens.buf); + free(ctxt); } } diff --git a/qemu/qobject/qbool.c b/qemu/qobject/qbool.c index a3d2afa8..d3ffbab3 100644 --- a/qemu/qobject/qbool.c +++ b/qemu/qobject/qbool.c @@ -64,5 +64,5 @@ QBool *qobject_to_qbool(const QObject *obj) static void qbool_destroy_obj(QObject *obj) { assert(obj != NULL); - g_free(qobject_to_qbool(obj)); + free(qobject_to_qbool(obj)); } diff --git a/qemu/qobject/qdict.c b/qemu/qobject/qdict.c index ea239f08..28921760 100644 --- a/qemu/qobject/qdict.c +++ b/qemu/qobject/qdict.c @@ -432,8 +432,8 @@ static void qentry_destroy(QDictEntry *e) assert(e->value != NULL); qobject_decref(e->value); - g_free(e->key); - g_free(e); + free(e->key); + free(e); } /** @@ -474,7 +474,7 @@ static void qdict_destroy_obj(QObject *obj) } } - g_free(qdict); + free(qdict); } static void qdict_flatten_qdict(QDict *qdict, QDict *target, @@ -509,7 +509,7 @@ static void qdict_flatten_qlist(QList *qlist, QDict *target, const char *prefix) qdict_put_obj(target, new_key, value); } - g_free(new_key); + free(new_key); } } @@ -550,7 +550,7 @@ static void qdict_flatten_qdict(QDict *qdict, QDict *target, const char *prefix) delete = true; } - g_free(new_key); + free(new_key); if (delete) { qdict_del(qdict, entry->key); diff --git a/qemu/qobject/qfloat.c b/qemu/qobject/qfloat.c index 7de0992d..60ccb4ed 100644 --- a/qemu/qobject/qfloat.c +++ b/qemu/qobject/qfloat.c @@ -64,5 +64,5 @@ QFloat *qobject_to_qfloat(const QObject *obj) static void qfloat_destroy_obj(QObject *obj) { assert(obj != NULL); - g_free(qobject_to_qfloat(obj)); + free(qobject_to_qfloat(obj)); } diff --git a/qemu/qobject/qint.c b/qemu/qobject/qint.c index 86b9b04f..e31a543c 100644 --- a/qemu/qobject/qint.c +++ b/qemu/qobject/qint.c @@ -63,5 +63,5 @@ QInt *qobject_to_qint(const QObject *obj) static void qint_destroy_obj(QObject *obj) { assert(obj != NULL); - g_free(qobject_to_qint(obj)); + free(qobject_to_qint(obj)); } diff --git a/qemu/qobject/qlist.c b/qemu/qobject/qlist.c index 1ced0de5..8b70b4f2 100644 --- a/qemu/qobject/qlist.c +++ b/qemu/qobject/qlist.c @@ -98,7 +98,7 @@ QObject *qlist_pop(QList *qlist) QTAILQ_REMOVE(&qlist->head, entry, next); ret = entry->value; - g_free(entry); + free(entry); return ret; } @@ -163,8 +163,8 @@ static void qlist_destroy_obj(QObject *obj) QTAILQ_FOREACH_SAFE(entry, &qlist->head, next, next_entry) { QTAILQ_REMOVE(&qlist->head, entry, next); qobject_decref(entry->value); - g_free(entry); + free(entry); } - g_free(qlist); + free(qlist); } diff --git a/qemu/qobject/qstring.c b/qemu/qobject/qstring.c index 607b7a14..3d27e719 100644 --- a/qemu/qobject/qstring.c +++ b/qemu/qobject/qstring.c @@ -144,6 +144,6 @@ static void qstring_destroy_obj(QObject *obj) assert(obj != NULL); qs = qobject_to_qstring(obj); - g_free(qs->string); - g_free(qs); + free(qs->string); + free(qs); } diff --git a/qemu/qom/cpu.c b/qemu/qom/cpu.c index 57922b5f..397dfaab 100644 --- a/qemu/qom/cpu.c +++ b/qemu/qom/cpu.c @@ -46,7 +46,7 @@ CPUState *cpu_generic_init(struct uc_struct *uc, const char *typename, const cha oc = cpu_class_by_name(uc, typename, name); if (oc == NULL) { - g_free(str); + free(str); return NULL; } @@ -55,7 +55,7 @@ CPUState *cpu_generic_init(struct uc_struct *uc, const char *typename, const cha featurestr = strtok(NULL, ","); cc->parse_features(cpu, featurestr, &err); - g_free(str); + free(str); if (err != NULL) { goto out; } diff --git a/qemu/qom/object.c b/qemu/qom/object.c index 71e4d5a9..46b5d4d3 100644 --- a/qemu/qom/object.c +++ b/qemu/qom/object.c @@ -15,7 +15,6 @@ #include "qapi/visitor.h" #include "qapi-visit.h" #include "qapi/string-input-visitor.h" -#include "qapi/string-output-visitor.h" #include "qapi/qmp/qerror.h" /* TODO: replace QObject with a simpler visitor to avoid a dependency @@ -228,7 +227,7 @@ static void type_initialize_interface(struct uc_struct *uc, TypeImpl *ti, TypeIm iface_impl = type_new(uc, &info); iface_impl->parent_type = parent_type; type_initialize(uc, iface_impl); - g_free((char *)info.name); + free((char *)info.name); new_iface = (InterfaceClass *)iface_impl->class; new_iface->concrete_class = ti->class; @@ -364,10 +363,10 @@ static void object_property_del_all(struct uc_struct *uc, Object *obj) prop->release(uc, obj, prop->name, prop->opaque); } - g_free(prop->name); - g_free(prop->type); - g_free(prop->description); - g_free(prop); + free(prop->name); + free(prop->type); + free(prop->description); + free(prop); } } @@ -424,7 +423,7 @@ static Object *object_new_with_type(struct uc_struct *uc, Type type) obj = g_malloc(type->instance_size); object_initialize_with_type(uc, obj, type->instance_size, type); - obj->free = g_free; + obj->free = free; return obj; } @@ -734,12 +733,12 @@ object_property_add(Object *obj, const char *name, const char *type, ret = object_property_add(obj, full_name, type, get, set, release, opaque, NULL); - g_free(full_name); + free(full_name); if (ret) { break; } } - g_free(name_no_array); + free(name_no_array); return ret; } @@ -794,10 +793,10 @@ void object_property_del(struct uc_struct *uc, Object *obj, const char *name, Er QTAILQ_REMOVE(&obj->properties, prop, node); - g_free(prop->name); - g_free(prop->type); - g_free(prop->description); - g_free(prop); + free(prop->name); + free(prop->type); + free(prop->description); + free(prop); } void object_property_get(struct uc_struct *uc, Object *obj, Visitor *v, const char *name, @@ -868,7 +867,7 @@ void object_property_set_link(struct uc_struct *uc, Object *obj, Object *value, if (value) { gchar *path = object_get_canonical_path(value); object_property_set_str(uc, obj, path, name, errp); - g_free(path); + free(path); } else { object_property_set_str(uc, obj, "", name, errp); } @@ -887,7 +886,7 @@ Object *object_property_get_link(struct uc_struct *uc, Object *obj, const char * } } - g_free(str); + free(str); return target; } @@ -953,48 +952,6 @@ int64_t object_property_get_int(struct uc_struct *uc, Object *obj, const char *n return retval; } -int object_property_get_enum(struct uc_struct *uc, Object *obj, const char *name, - const char *strings[], Error **errp) -{ - StringOutputVisitor *sov; - StringInputVisitor *siv; - char *str; - int ret; - - sov = string_output_visitor_new(false); - object_property_get(uc, obj, string_output_get_visitor(sov), name, errp); - str = string_output_get_string(sov); - siv = string_input_visitor_new(str); - string_output_visitor_cleanup(sov); - visit_type_enum(string_input_get_visitor(siv), - &ret, strings, NULL, name, errp); - - g_free(str); - string_input_visitor_cleanup(siv); - - return ret; -} - -void object_property_get_uint16List(struct uc_struct *uc, Object *obj, const char *name, - uint16List **list, Error **errp) -{ - StringOutputVisitor *ov; - StringInputVisitor *iv; - char *str; - - ov = string_output_visitor_new(false); - object_property_get(uc, obj, string_output_get_visitor(ov), - name, errp); - str = string_output_get_string(ov); - iv = string_input_visitor_new(str); - visit_type_uint16List(string_input_get_visitor(iv), - list, NULL, errp); - - g_free(str); - string_output_visitor_cleanup(ov); - string_input_visitor_cleanup(iv); -} - void object_property_parse(struct uc_struct *uc, Object *obj, const char *string, const char *name, Error **errp) { @@ -1005,27 +962,6 @@ void object_property_parse(struct uc_struct *uc, Object *obj, const char *string string_input_visitor_cleanup(mi); } -char *object_property_print(struct uc_struct *uc, Object *obj, const char *name, bool human, - Error **errp) -{ - StringOutputVisitor *mo; - char *string = NULL; - Error *local_err = NULL; - - mo = string_output_visitor_new(human); - object_property_get(uc, obj, string_output_get_visitor(mo), name, &local_err); - if (local_err) { - error_propagate(errp, local_err); - goto out; - } - - string = string_output_get_string(mo); - -out: - string_output_visitor_cleanup(mo); - return string; -} - const char *object_property_get_type(Object *obj, const char *name, Error **errp) { ObjectProperty *prop = object_property_find(obj, name, errp); @@ -1053,7 +989,7 @@ static void object_get_child_property(struct uc_struct *uc, Object *obj, Visitor path = object_get_canonical_path(child); visit_type_str(v, &path, name, errp); - g_free(path); + free(path); } static Object *object_resolve_child_property(struct uc_struct *uc, Object *parent, void *opaque, const gchar *part) @@ -1099,7 +1035,7 @@ void object_property_add_child(Object *obj, const char *name, child->parent = obj; out: - g_free(type); + free(type); } void object_property_allow_set_link(Object *obj, const char *name, @@ -1124,7 +1060,7 @@ static void object_get_link_property(struct uc_struct *uc, Object *obj, Visitor if (*child) { path = object_get_canonical_path(*child); visit_type_str(v, &path, name, errp); - g_free(path); + free(path); } else { path = (gchar *)""; visit_type_str(v, &path, name, errp); @@ -1165,7 +1101,7 @@ static Object *object_resolve_link(struct uc_struct *uc, Object *obj, const char } target = NULL; } - g_free(target_type); + free(target_type); return target; } @@ -1186,7 +1122,7 @@ static int object_set_link_property(struct uc_struct *uc, Object *obj, Visitor * new_target = object_resolve_link(uc, obj, name, path, &local_err); } - g_free(path); + free(path); if (local_err) { error_propagate(errp, local_err); return -1; @@ -1220,7 +1156,7 @@ static void object_release_link_property(struct uc_struct *uc, Object *obj, cons if ((prop->flags & OBJ_PROP_LINK_UNREF_ON_RELEASE) && *prop->child) { object_unref(uc, *prop->child); } - g_free(prop); + free(prop); } void object_property_add_link(Object *obj, const char *name, @@ -1249,14 +1185,14 @@ void object_property_add_link(Object *obj, const char *name, &local_err); if (local_err) { error_propagate(errp, local_err); - g_free(prop); + free(prop); goto out; } op->resolve = object_resolve_link_property; out: - g_free(full_type); + free(full_type); } gchar *object_get_canonical_path_component(Object *obj) @@ -1291,8 +1227,8 @@ gchar *object_get_canonical_path(Object *obj) if (path) { newpath = g_strdup_printf("%s/%s", component, path); - g_free(component); - g_free(path); + free(component); + free(path); path = newpath; } else { path = component; @@ -1302,7 +1238,7 @@ gchar *object_get_canonical_path(Object *obj) } newpath = g_strdup_printf("/%s", path ? path : ""); - g_free(path); + free(path); return newpath; } @@ -1425,7 +1361,7 @@ static void property_get_str(struct uc_struct *uc, Object *obj, Visitor *v, void value = prop->get(uc, obj, errp); if (value) { visit_type_str(v, &value, name, errp); - g_free(value); + free(value); } } @@ -1443,7 +1379,7 @@ static int property_set_str(struct uc_struct *uc, Object *obj, Visitor *v, void } prop->set(uc, obj, value, errp); - g_free(value); + free(value); return 0; } @@ -1452,7 +1388,7 @@ static void property_release_str(struct uc_struct *uc, Object *obj, const char * void *opaque) { StringProperty *prop = opaque; - g_free(prop); + free(prop); } void object_property_add_str(Object *obj, const char *name, @@ -1473,7 +1409,7 @@ void object_property_add_str(Object *obj, const char *name, prop, &local_err); if (local_err) { error_propagate(errp, local_err); - g_free(prop); + free(prop); } } @@ -1513,7 +1449,7 @@ static void property_release_bool(struct uc_struct *uc, Object *obj, const char void *opaque) { BoolProperty *prop = opaque; - g_free(prop); + free(prop); } void object_property_add_bool(struct uc_struct *uc, Object *obj, const char *name, @@ -1534,7 +1470,7 @@ void object_property_add_bool(struct uc_struct *uc, Object *obj, const char *nam prop, &local_err); if (local_err) { error_propagate(errp, local_err); - g_free(prop); + free(prop); } } @@ -1638,7 +1574,7 @@ static void property_release_alias(struct uc_struct *uc, Object *obj, const char { AliasProperty *prop = opaque; - g_free(prop); + free(prop); } void object_property_add_alias(Object *obj, const char *name, @@ -1674,7 +1610,7 @@ void object_property_add_alias(Object *obj, const char *name, prop, &local_err); if (local_err) { error_propagate(errp, local_err); - g_free(prop); + free(prop); goto out; } op->resolve = property_resolve_alias; @@ -1684,7 +1620,7 @@ void object_property_add_alias(Object *obj, const char *name, &error_abort); out: - g_free(prop_type); + free(prop_type); } void object_property_set_description(Object *obj, const char *name, @@ -1697,7 +1633,7 @@ void object_property_set_description(Object *obj, const char *name, return; } - g_free(op->description); + free(op->description); op->description = g_strdup(description); } diff --git a/qemu/sparc.h b/qemu/sparc.h index b9fe4297..80e9b34f 100644 --- a/qemu/sparc.h +++ b/qemu/sparc.h @@ -2179,15 +2179,12 @@ #define object_property_find object_property_find_sparc #define object_property_get object_property_get_sparc #define object_property_get_bool object_property_get_bool_sparc -#define object_property_get_enum object_property_get_enum_sparc #define object_property_get_int object_property_get_int_sparc #define object_property_get_link object_property_get_link_sparc #define object_property_get_qobject object_property_get_qobject_sparc #define object_property_get_str object_property_get_str_sparc #define object_property_get_type object_property_get_type_sparc -#define object_property_get_uint16List object_property_get_uint16List_sparc #define object_property_is_child object_property_is_child_sparc -#define object_property_print object_property_print_sparc #define object_property_set object_property_set_sparc #define object_property_set_description object_property_set_description_sparc #define object_property_set_link object_property_set_link_sparc @@ -2427,7 +2424,6 @@ #define qemu_get_cpu qemu_get_cpu_sparc #define qemu_get_guest_memory_mapping qemu_get_guest_memory_mapping_sparc #define qemu_get_guest_simple_memory_mapping qemu_get_guest_simple_memory_mapping_sparc -#define qemu_get_local_state_pathname qemu_get_local_state_pathname_sparc #define qemu_get_ram_block qemu_get_ram_block_sparc #define qemu_get_ram_block_host_ptr qemu_get_ram_block_host_ptr_sparc #define qemu_get_ram_fd qemu_get_ram_fd_sparc @@ -2716,13 +2712,6 @@ #define string_input_get_visitor string_input_get_visitor_sparc #define string_input_visitor_cleanup string_input_visitor_cleanup_sparc #define string_input_visitor_new string_input_visitor_new_sparc -#define string_output_append string_output_append_sparc -#define string_output_append_range string_output_append_range_sparc -#define string_output_get_string string_output_get_string_sparc -#define string_output_get_visitor string_output_get_visitor_sparc -#define string_output_set string_output_set_sparc -#define string_output_visitor_cleanup string_output_visitor_cleanup_sparc -#define string_output_visitor_new string_output_visitor_new_sparc #define stristart stristart_sparc #define strongarm_cp_reginfo strongarm_cp_reginfo_sparc #define strpadcpy strpadcpy_sparc diff --git a/qemu/sparc64.h b/qemu/sparc64.h index a34d4193..733b59dc 100644 --- a/qemu/sparc64.h +++ b/qemu/sparc64.h @@ -2179,15 +2179,12 @@ #define object_property_find object_property_find_sparc64 #define object_property_get object_property_get_sparc64 #define object_property_get_bool object_property_get_bool_sparc64 -#define object_property_get_enum object_property_get_enum_sparc64 #define object_property_get_int object_property_get_int_sparc64 #define object_property_get_link object_property_get_link_sparc64 #define object_property_get_qobject object_property_get_qobject_sparc64 #define object_property_get_str object_property_get_str_sparc64 #define object_property_get_type object_property_get_type_sparc64 -#define object_property_get_uint16List object_property_get_uint16List_sparc64 #define object_property_is_child object_property_is_child_sparc64 -#define object_property_print object_property_print_sparc64 #define object_property_set object_property_set_sparc64 #define object_property_set_description object_property_set_description_sparc64 #define object_property_set_link object_property_set_link_sparc64 @@ -2427,7 +2424,6 @@ #define qemu_get_cpu qemu_get_cpu_sparc64 #define qemu_get_guest_memory_mapping qemu_get_guest_memory_mapping_sparc64 #define qemu_get_guest_simple_memory_mapping qemu_get_guest_simple_memory_mapping_sparc64 -#define qemu_get_local_state_pathname qemu_get_local_state_pathname_sparc64 #define qemu_get_ram_block qemu_get_ram_block_sparc64 #define qemu_get_ram_block_host_ptr qemu_get_ram_block_host_ptr_sparc64 #define qemu_get_ram_fd qemu_get_ram_fd_sparc64 @@ -2716,13 +2712,6 @@ #define string_input_get_visitor string_input_get_visitor_sparc64 #define string_input_visitor_cleanup string_input_visitor_cleanup_sparc64 #define string_input_visitor_new string_input_visitor_new_sparc64 -#define string_output_append string_output_append_sparc64 -#define string_output_append_range string_output_append_range_sparc64 -#define string_output_get_string string_output_get_string_sparc64 -#define string_output_get_visitor string_output_get_visitor_sparc64 -#define string_output_set string_output_set_sparc64 -#define string_output_visitor_cleanup string_output_visitor_cleanup_sparc64 -#define string_output_visitor_new string_output_visitor_new_sparc64 #define stristart stristart_sparc64 #define strongarm_cp_reginfo strongarm_cp_reginfo_sparc64 #define strpadcpy strpadcpy_sparc64 diff --git a/qemu/target-arm/cpu.c b/qemu/target-arm/cpu.c index 3373be6b..1716bf60 100644 --- a/qemu/target-arm/cpu.c +++ b/qemu/target-arm/cpu.c @@ -273,7 +273,7 @@ static void arm_cpu_initfn(struct uc_struct *uc, Object *obj, void *opaque) cs->env_ptr = &cpu->env; cpu_exec_init(&cpu->env, opaque); cpu->cp_regs = g_hash_table_new_full(g_int_hash, g_int_equal, - g_free, g_free); + free, free); #if 0 #ifndef CONFIG_USER_ONLY @@ -414,7 +414,7 @@ static ObjectClass *arm_cpu_class_by_name(struct uc_struct *uc, const char *cpu_ typename = g_strdup_printf("%s-" TYPE_ARM_CPU, cpu_model); oc = object_class_by_name(uc, typename); - g_free(typename); + free(typename); if (!oc || !object_class_dynamic_cast(uc, oc, TYPE_ARM_CPU) || object_class_is_abstract(oc)) { return NULL; @@ -1084,7 +1084,7 @@ static void cpu_register(struct uc_struct *uc, const ARMCPUInfo *info) type_info.name = g_strdup_printf("%s-" TYPE_ARM_CPU, info->name); type_register(uc, &type_info); - g_free((void *)type_info.name); + free((void *)type_info.name); } void arm_cpu_register_types(void *opaque) diff --git a/qemu/target-arm/cpu64.c b/qemu/target-arm/cpu64.c index fcccd996..442d964e 100644 --- a/qemu/target-arm/cpu64.c +++ b/qemu/target-arm/cpu64.c @@ -212,7 +212,7 @@ static void aarch64_cpu_register(struct uc_struct *uc, const ARMCPUInfo *info) type_info.name = g_strdup_printf("%s-" TYPE_ARM_CPU, info->name); type_register(uc, &type_info); - g_free((void *)type_info.name); + free((void *)type_info.name); } void aarch64_cpu_register_types(void *opaque) diff --git a/qemu/target-arm/helper.c b/qemu/target-arm/helper.c index b3ba828b..3fe31576 100644 --- a/qemu/target-arm/helper.c +++ b/qemu/target-arm/helper.c @@ -155,7 +155,7 @@ static void count_cpreg(gpointer key, gpointer opaque) } } -static gint cpreg_key_compare(gconstpointer a, gconstpointer b) +static int32_t cpreg_key_compare(gconstpointer a, gconstpointer b) { uint64_t aidx = cpreg_to_kvm_id(*(uint32_t *)a); uint64_t bidx = cpreg_to_kvm_id(*(uint32_t *)b); @@ -3102,7 +3102,7 @@ static void arm_cpu_list_entry(gpointer data, gpointer user_data) name = g_strndup(typename, strlen(typename) - strlen("-" TYPE_ARM_CPU)); (*s->cpu_fprintf)(s->file, " %s\n", name); - g_free(name); + free(name); } #endif diff --git a/qemu/target-arm/unicorn_aarch64.c b/qemu/target-arm/unicorn_aarch64.c index 1d9fb328..bbd0b7fa 100644 --- a/qemu/target-arm/unicorn_aarch64.c +++ b/qemu/target-arm/unicorn_aarch64.c @@ -23,13 +23,13 @@ void arm64_release(void* ctx) { TCGContext *s = (TCGContext *) ctx; - g_free(s->tb_ctx.tbs); + free(s->tb_ctx.tbs); struct uc_struct* uc = s->uc; ARMCPU* cpu = (ARMCPU*) uc->cpu; - g_free(cpu->cpreg_indexes); - g_free(cpu->cpreg_values); - g_free(cpu->cpreg_vmstate_indexes); - g_free(cpu->cpreg_vmstate_values); + free(cpu->cpreg_indexes); + free(cpu->cpreg_values); + free(cpu->cpreg_vmstate_indexes); + free(cpu->cpreg_vmstate_values); release_common(ctx); } diff --git a/qemu/target-arm/unicorn_arm.c b/qemu/target-arm/unicorn_arm.c index 9e7cf575..90c031be 100644 --- a/qemu/target-arm/unicorn_arm.c +++ b/qemu/target-arm/unicorn_arm.c @@ -24,13 +24,13 @@ void arm_release(void* ctx) { TCGContext *s = (TCGContext *) ctx; - g_free(s->tb_ctx.tbs); + free(s->tb_ctx.tbs); struct uc_struct* uc = s->uc; ARMCPU* cpu = (ARMCPU*) uc->cpu; - g_free(cpu->cpreg_indexes); - g_free(cpu->cpreg_values); - g_free(cpu->cpreg_vmstate_indexes); - g_free(cpu->cpreg_vmstate_values); + free(cpu->cpreg_indexes); + free(cpu->cpreg_values); + free(cpu->cpreg_vmstate_indexes); + free(cpu->cpreg_vmstate_values); release_common(ctx); } diff --git a/qemu/target-i386/cpu.c b/qemu/target-i386/cpu.c index d8b58510..3f8cc917 100644 --- a/qemu/target-i386/cpu.c +++ b/qemu/target-i386/cpu.c @@ -523,7 +523,7 @@ static ObjectClass *x86_cpu_class_by_name(struct uc_struct *uc, const char *cpu_ typename = x86_cpu_type_name(cpu_model); oc = object_class_by_name(uc, typename); - g_free(typename); + free(typename); return oc; } @@ -1756,7 +1756,7 @@ static void x86_register_cpudef_type(struct uc_struct *uc, X86CPUDefinition *def }; type_register(uc, &ti); - g_free(typename); + free(typename); } #if !defined(CONFIG_USER_ONLY) diff --git a/qemu/target-i386/helper.c b/qemu/target-i386/helper.c index 5341094e..b059d87f 100644 --- a/qemu/target-i386/helper.c +++ b/qemu/target-i386/helper.c @@ -1112,7 +1112,7 @@ void do_cpu_init(X86CPU *cpu) memcpy(&env->start_init_save, &save->start_init_save, offsetof(CPUX86State, end_init_save) - offsetof(CPUX86State, start_init_save)); - g_free(save); + free(save); apic_init_reset(env->uc, cpu->apic_state); } diff --git a/qemu/target-i386/unicorn.c b/qemu/target-i386/unicorn.c index 5005c2f9..bf64a5b4 100644 --- a/qemu/target-i386/unicorn.c +++ b/qemu/target-i386/unicorn.c @@ -29,21 +29,21 @@ void x86_release(void *ctx) release_common(ctx); // arch specific - g_free(s->cpu_A0); - g_free(s->cpu_T[0]); - g_free(s->cpu_T[1]); - g_free(s->cpu_tmp0); - g_free(s->cpu_tmp4); - g_free(s->cpu_cc_srcT); - g_free(s->cpu_cc_dst); - g_free(s->cpu_cc_src); - g_free(s->cpu_cc_src2); + free(s->cpu_A0); + free(s->cpu_T[0]); + free(s->cpu_T[1]); + free(s->cpu_tmp0); + free(s->cpu_tmp4); + free(s->cpu_cc_srcT); + free(s->cpu_cc_dst); + free(s->cpu_cc_src); + free(s->cpu_cc_src2); for (i = 0; i < CPU_NB_REGS; ++i) { - g_free(s->cpu_regs[i]); + free(s->cpu_regs[i]); } - g_free(s->tb_ctx.tbs); + free(s->tb_ctx.tbs); } void x86_reg_reset(struct uc_struct *uc) diff --git a/qemu/target-m68k/cpu.c b/qemu/target-m68k/cpu.c index 19e00067..23d7e329 100644 --- a/qemu/target-m68k/cpu.c +++ b/qemu/target-m68k/cpu.c @@ -74,7 +74,7 @@ static ObjectClass *m68k_cpu_class_by_name(struct uc_struct *uc, const char *cpu typename = g_strdup_printf("%s-" TYPE_M68K_CPU, cpu_model); oc = object_class_by_name(uc, typename); - g_free(typename); + free(typename); if (oc != NULL && (object_class_dynamic_cast(uc, oc, TYPE_M68K_CPU) == NULL || object_class_is_abstract(oc))) { return NULL; @@ -208,7 +208,7 @@ static void register_cpu_type(void *opaque, const M68kCPUInfo *info) type_info.name = g_strdup_printf("%s-" TYPE_M68K_CPU, info->name); type_register(opaque, &type_info); - g_free((void *)type_info.name); + free((void *)type_info.name); } void m68k_cpu_register_types(void *opaque) diff --git a/qemu/target-m68k/unicorn.c b/qemu/target-m68k/unicorn.c index 18befef0..aa78a5f8 100644 --- a/qemu/target-m68k/unicorn.c +++ b/qemu/target-m68k/unicorn.c @@ -22,24 +22,24 @@ void m68k_release(void* ctx) { release_common(ctx); TCGContext *tcg_ctx = (TCGContext *) ctx; - g_free(tcg_ctx->tb_ctx.tbs); - g_free(tcg_ctx->QREG_PC); - g_free(tcg_ctx->QREG_SR); - g_free(tcg_ctx->QREG_CC_OP); - g_free(tcg_ctx->QREG_CC_DEST); - g_free(tcg_ctx->QREG_CC_SRC); - g_free(tcg_ctx->QREG_CC_X); - g_free(tcg_ctx->QREG_DIV1); - g_free(tcg_ctx->QREG_DIV2); - g_free(tcg_ctx->QREG_MACSR); - g_free(tcg_ctx->QREG_MAC_MASK); + free(tcg_ctx->tb_ctx.tbs); + free(tcg_ctx->QREG_PC); + free(tcg_ctx->QREG_SR); + free(tcg_ctx->QREG_CC_OP); + free(tcg_ctx->QREG_CC_DEST); + free(tcg_ctx->QREG_CC_SRC); + free(tcg_ctx->QREG_CC_X); + free(tcg_ctx->QREG_DIV1); + free(tcg_ctx->QREG_DIV2); + free(tcg_ctx->QREG_MACSR); + free(tcg_ctx->QREG_MAC_MASK); int i; for (i = 0; i < 8; i++) { - g_free(tcg_ctx->cpu_dregs[i]); - g_free(tcg_ctx->cpu_aregs[i]); + free(tcg_ctx->cpu_dregs[i]); + free(tcg_ctx->cpu_aregs[i]); } - g_free(tcg_ctx->NULL_QREG); - g_free(tcg_ctx->store_dummy); + free(tcg_ctx->NULL_QREG); + free(tcg_ctx->store_dummy); } void m68k_reg_reset(struct uc_struct *uc) diff --git a/qemu/target-mips/unicorn.c b/qemu/target-mips/unicorn.c index 3ca24390..e4c8e3c1 100644 --- a/qemu/target-mips/unicorn.c +++ b/qemu/target-mips/unicorn.c @@ -46,24 +46,24 @@ void mips_release(void *ctx) TCGContext *tcg_ctx = (TCGContext *) ctx; release_common(ctx); MIPSCPU* cpu = MIPS_CPU(tcg_ctx->uc, tcg_ctx->uc->cpu); - g_free(cpu->env.tlb); - g_free(cpu->env.mvp); + free(cpu->env.tlb); + free(cpu->env.mvp); for (i = 0; i < MIPS_DSP_ACC; i++) { - g_free(tcg_ctx->cpu_HI[i]); - g_free(tcg_ctx->cpu_LO[i]); + free(tcg_ctx->cpu_HI[i]); + free(tcg_ctx->cpu_LO[i]); } for (i = 0; i < 32; i++) { - g_free(tcg_ctx->cpu_gpr[i]); + free(tcg_ctx->cpu_gpr[i]); } - g_free(tcg_ctx->cpu_PC); - g_free(tcg_ctx->btarget); - g_free(tcg_ctx->bcond); - g_free(tcg_ctx->cpu_dspctrl); + free(tcg_ctx->cpu_PC); + free(tcg_ctx->btarget); + free(tcg_ctx->bcond); + free(tcg_ctx->cpu_dspctrl); - g_free(tcg_ctx->tb_ctx.tbs); + free(tcg_ctx->tb_ctx.tbs); } void mips_reg_reset(struct uc_struct *uc) diff --git a/qemu/target-sparc/cpu.c b/qemu/target-sparc/cpu.c index c3f779b7..f1e88742 100644 --- a/qemu/target-sparc/cpu.c +++ b/qemu/target-sparc/cpu.c @@ -100,7 +100,7 @@ static int cpu_sparc_register(struct uc_struct *uc, SPARCCPU *cpu, const char *c Error *err = NULL; if (cpu_sparc_find_by_name(def, name) < 0) { - g_free(s); + free(s); return -1; } @@ -109,7 +109,7 @@ static int cpu_sparc_register(struct uc_struct *uc, SPARCCPU *cpu, const char *c featurestr = strtok(NULL, ","); cc->parse_features(CPU(cpu), featurestr, &err); - g_free(s); + free(s); if (err) { //error_report("%s", error_get_pretty(err)); error_free(err); @@ -821,7 +821,7 @@ static void sparc_cpu_uninitfn(struct uc_struct *uc, Object *obj, void *opaque) SPARCCPU *cpu = SPARC_CPU(uc, obj); CPUSPARCState *env = &cpu->env; - g_free(env->def); + free(env->def); } static void sparc_cpu_class_init(struct uc_struct *uc, ObjectClass *oc, void *data) diff --git a/qemu/target-sparc/unicorn.c b/qemu/target-sparc/unicorn.c index 354d48ca..28ebe2db 100644 --- a/qemu/target-sparc/unicorn.c +++ b/qemu/target-sparc/unicorn.c @@ -34,30 +34,30 @@ void sparc_release(void *ctx) int i; TCGContext *tcg_ctx = (TCGContext *) ctx; release_common(ctx); - g_free(tcg_ctx->cpu_wim); - g_free(tcg_ctx->cpu_cond); - g_free(tcg_ctx->cpu_cc_src); - g_free(tcg_ctx->cpu_cc_src2); - g_free(tcg_ctx->cpu_cc_dst); - g_free(tcg_ctx->cpu_fsr); - g_free(tcg_ctx->sparc_cpu_pc); - g_free(tcg_ctx->cpu_npc); - g_free(tcg_ctx->cpu_y); - g_free(tcg_ctx->cpu_tbr); + free(tcg_ctx->cpu_wim); + free(tcg_ctx->cpu_cond); + free(tcg_ctx->cpu_cc_src); + free(tcg_ctx->cpu_cc_src2); + free(tcg_ctx->cpu_cc_dst); + free(tcg_ctx->cpu_fsr); + free(tcg_ctx->sparc_cpu_pc); + free(tcg_ctx->cpu_npc); + free(tcg_ctx->cpu_y); + free(tcg_ctx->cpu_tbr); for (i = 0; i < 8; i++) { - g_free(tcg_ctx->cpu_gregs[i]); + free(tcg_ctx->cpu_gregs[i]); } for (i = 0; i < 32; i++) { - g_free(tcg_ctx->cpu_gpr[i]); + free(tcg_ctx->cpu_gpr[i]); } - g_free(tcg_ctx->cpu_PC); - g_free(tcg_ctx->btarget); - g_free(tcg_ctx->bcond); - g_free(tcg_ctx->cpu_dspctrl); + free(tcg_ctx->cpu_PC); + free(tcg_ctx->btarget); + free(tcg_ctx->bcond); + free(tcg_ctx->cpu_dspctrl); - g_free(tcg_ctx->tb_ctx.tbs); + free(tcg_ctx->tb_ctx.tbs); } void sparc_reg_reset(struct uc_struct *uc) diff --git a/qemu/tcg/tcg.c b/qemu/tcg/tcg.c index 6c0a09cf..788146fe 100644 --- a/qemu/tcg/tcg.c +++ b/qemu/tcg/tcg.c @@ -299,7 +299,7 @@ void tcg_pool_reset(TCGContext *s) TCGPool *p, *t; for (p = s->pool_first_large; p; p = t) { t = p->next; - g_free(p); + free(p); } s->pool_first_large = NULL; s->pool_cur = s->pool_end = NULL; diff --git a/qemu/translate-all.c b/qemu/translate-all.c index 4f10c633..8c5d8a35 100644 --- a/qemu/translate-all.c +++ b/qemu/translate-all.c @@ -142,7 +142,7 @@ static void tb_clean_internal(struct uc_struct *uc, int i, void** lp) } tb_clean_internal(uc, i-1, (*lp) + ((0 >> (i * V_L2_BITS)) & (V_L2_SIZE - 1))); if (lp && *lp) { - g_free(*lp); + free(*lp); } } @@ -667,7 +667,7 @@ void free_code_gen_buffer(struct uc_struct *uc) { TCGContext *tcg_ctx = uc->tcg_ctx; if (tcg_ctx->code_gen_buffer) - g_free(tcg_ctx->code_gen_buffer); + free(tcg_ctx->code_gen_buffer); } static inline void *alloc_code_gen_buffer(struct uc_struct *uc) @@ -792,7 +792,7 @@ void tb_free(struct uc_struct *uc, TranslationBlock *tb) static inline void invalidate_page_bitmap(PageDesc *p) { if (p->code_bitmap) { - g_free(p->code_bitmap); + free(p->code_bitmap); p->code_bitmap = NULL; } p->code_write_count = 0; diff --git a/qemu/unicorn_common.h b/qemu/unicorn_common.h index bd8b5f6c..9be2e982 100644 --- a/qemu/unicorn_common.h +++ b/qemu/unicorn_common.h @@ -32,14 +32,14 @@ static void release_common(void *t) // Clean TCG. TCGOpDef* def = &s->tcg_op_defs[0]; - g_free(def->args_ct); - g_free(def->sorted_args); - g_free(s->tcg_op_defs); + free(def->args_ct); + free(def->sorted_args); + free(s->tcg_op_defs); TCGPool *po, *to; for (po = s->pool_first; po; po = to) { to = po->next; - g_free(po); + free(po); } tcg_pool_reset(s); g_hash_table_destroy(s->helpers); diff --git a/qemu/util/error.c b/qemu/util/error.c index 9c49facb..ae5af596 100644 --- a/qemu/util/error.c +++ b/qemu/util/error.c @@ -67,7 +67,7 @@ void error_set_errno(Error **errp, int os_errno, ErrorClass err_class, msg1 = g_strdup_vprintf(fmt, ap); if (os_errno != 0) { err->msg = g_strdup_printf("%s: %s", msg1, strerror(os_errno)); - g_free(msg1); + free(msg1); } else { err->msg = msg1; } @@ -110,8 +110,8 @@ void error_set_win32(Error **errp, int win32_err, ErrorClass err_class, char *msg2 = g_win32_error_message(win32_err); err->msg = g_strdup_printf("%s: %s (error: %x)", msg1, msg2, (unsigned)win32_err); - g_free(msg2); - g_free(msg1); + free(msg2); + free(msg1); } else { err->msg = msg1; } @@ -152,8 +152,8 @@ const char *error_get_pretty(Error *err) void error_free(Error *err) { if (err) { - g_free(err->msg); - g_free(err); + free(err->msg); + free(err); } } diff --git a/qemu/util/oslib-posix.c b/qemu/util/oslib-posix.c index 49e902f7..47e8c984 100644 --- a/qemu/util/oslib-posix.c +++ b/qemu/util/oslib-posix.c @@ -51,8 +51,6 @@ extern int daemon(int, int); #include #include -#include - #include "config-host.h" #include "sysemu/sysemu.h" #include @@ -183,13 +181,6 @@ int qemu_pipe(int pipefd[2]) return ret; } -char * -qemu_get_local_state_pathname(const char *relative_pathname) -{ - return g_strdup_printf("%s/%s", CONFIG_QEMU_LOCALSTATEDIR, - relative_pathname); -} - void qemu_set_tty_echo(int fd, bool echo) { struct termios tty; diff --git a/qemu/util/oslib-win32.c b/qemu/util/oslib-win32.c index c7590935..eb7a9fe1 100644 --- a/qemu/util/oslib-win32.c +++ b/qemu/util/oslib-win32.c @@ -25,15 +25,9 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. * - * The implementation of g_poll (functions poll_rest, g_poll) at the end of - * this file are based on code from GNOME glib-2 and use a different license, - * see the license comment there. */ #include -#define G_OS_WIN32 - -#include #include #include "config-host.h" #include "sysemu/sysemu.h" @@ -156,23 +150,6 @@ int qemu_gettimeofday(qemu_timeval *tp) return 0; } -char * -qemu_get_local_state_pathname(const char *relative_pathname) -{ - HRESULT result; - char base_path[MAX_PATH+1] = ""; - - result = SHGetFolderPath(NULL, CSIDL_COMMON_APPDATA, NULL, - /* SHGFP_TYPE_CURRENT */ 0, base_path); - if (result != S_OK) { - /* misconfigured environment */ - g_critical("CSIDL_COMMON_APPDATA unavailable: %ld", (long)result); - abort(); - } - return g_strdup_printf("%s" G_DIR_SEPARATOR_S "%s", base_path, - relative_pathname); -} - void qemu_set_tty_echo(int fd, bool echo) { HANDLE handle = (HANDLE)_get_osfhandle(fd); @@ -192,210 +169,6 @@ void qemu_set_tty_echo(int fd, bool echo) } } -/* - * The original implementation of g_poll from glib has a problem on Windows - * when using timeouts < 10 ms. - * - * Whenever g_poll is called with timeout < 10 ms, it does a quick poll instead - * of wait. This causes significant performance degradation of QEMU. - * - * The following code is a copy of the original code from glib/gpoll.c - * (glib commit 20f4d1820b8d4d0fc4447188e33efffd6d4a88d8 from 2014-02-19). - * Some debug code was removed and the code was reformatted. - * All other code modifications are marked with 'QEMU'. - */ - -/* - * gpoll.c: poll(2) abstraction - * Copyright 1998 Owen Taylor - * Copyright 2008 Red Hat, Inc. - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, see . - */ - -static int poll_rest(gboolean poll_msgs, HANDLE *handles, gint nhandles, - GPollFD *fds, guint nfds, gint timeout) -{ - DWORD ready; - GPollFD *f; - int recursed_result; - - if (poll_msgs) { - /* Wait for either messages or handles - * -> Use MsgWaitForMultipleObjectsEx - */ - ready = MsgWaitForMultipleObjectsEx(nhandles, handles, timeout, - QS_ALLINPUT, MWMO_ALERTABLE); - - if (ready == WAIT_FAILED) { - gchar *emsg = g_win32_error_message(GetLastError()); - g_warning("MsgWaitForMultipleObjectsEx failed: %s", emsg); - g_free(emsg); - } - } else if (nhandles == 0) { - /* No handles to wait for, just the timeout */ - if (timeout == INFINITE) { - ready = WAIT_FAILED; - } else { - SleepEx(timeout, TRUE); - ready = WAIT_TIMEOUT; - } - } else { - /* Wait for just handles - * -> Use WaitForMultipleObjectsEx - */ - ready = - WaitForMultipleObjectsEx(nhandles, handles, FALSE, timeout, TRUE); - if (ready == WAIT_FAILED) { - gchar *emsg = g_win32_error_message(GetLastError()); - g_warning("WaitForMultipleObjectsEx failed: %s", emsg); - g_free(emsg); - } - } - - if (ready == WAIT_FAILED) { - return -1; - } else if (ready == WAIT_TIMEOUT || ready == WAIT_IO_COMPLETION) { - return 0; - } else if (poll_msgs && ready == WAIT_OBJECT_0 + nhandles) { - for (f = fds; f < &fds[nfds]; ++f) { - if (f->fd == G_WIN32_MSG_HANDLE && f->events & G_IO_IN) { - f->revents |= G_IO_IN; - } - } - - /* If we have a timeout, or no handles to poll, be satisfied - * with just noticing we have messages waiting. - */ - if (timeout != 0 || nhandles == 0) { - return 1; - } - - /* If no timeout and handles to poll, recurse to poll them, - * too. - */ - recursed_result = poll_rest(FALSE, handles, nhandles, fds, nfds, 0); - return (recursed_result == -1) ? -1 : 1 + recursed_result; - } else if (/* QEMU: removed the following unneeded statement which causes - * a compiler warning: ready >= WAIT_OBJECT_0 && */ - ready < WAIT_OBJECT_0 + nhandles) { - for (f = fds; f < &fds[nfds]; ++f) { - if ((HANDLE) f->fd == handles[ready - WAIT_OBJECT_0]) { - f->revents = f->events; - } - } - - /* If no timeout and polling several handles, recurse to poll - * the rest of them. - */ - if (timeout == 0 && nhandles > 1) { - /* Remove the handle that fired */ - int i; - if (ready < nhandles - 1) { - for (i = ready - WAIT_OBJECT_0 + 1; i < nhandles; i++) { - handles[i-1] = handles[i]; - } - } - nhandles--; - recursed_result = poll_rest(FALSE, handles, nhandles, fds, nfds, 0); - return (recursed_result == -1) ? -1 : 1 + recursed_result; - } - return 1; - } - - return 0; -} - -gint g_poll(GPollFD *fds, guint nfds, gint timeout) -{ - HANDLE handles[MAXIMUM_WAIT_OBJECTS]; - gboolean poll_msgs = FALSE; - GPollFD *f; - gint nhandles = 0; - int retval; - - for (f = fds; f < &fds[nfds]; ++f) { - if (f->fd == G_WIN32_MSG_HANDLE && (f->events & G_IO_IN)) { - poll_msgs = TRUE; - } else if (f->fd > 0) { - /* Don't add the same handle several times into the array, as - * docs say that is not allowed, even if it actually does seem - * to work. - */ - gint i; - - for (i = 0; i < nhandles; i++) { - if (handles[i] == (HANDLE) f->fd) { - break; - } - } - - if (i == nhandles) { - if (nhandles == MAXIMUM_WAIT_OBJECTS) { - g_warning("Too many handles to wait for!\n"); - break; - } else { - handles[nhandles++] = (HANDLE) f->fd; - } - } - } - } - - for (f = fds; f < &fds[nfds]; ++f) { - f->revents = 0; - } - - if (timeout == -1) { - timeout = INFINITE; - } - - /* Polling for several things? */ - if (nhandles > 1 || (nhandles > 0 && poll_msgs)) { - /* First check if one or several of them are immediately - * available - */ - retval = poll_rest(poll_msgs, handles, nhandles, fds, nfds, 0); - - /* If not, and we have a significant timeout, poll again with - * timeout then. Note that this will return indication for only - * one event, or only for messages. We ignore timeouts less than - * ten milliseconds as they are mostly pointless on Windows, the - * MsgWaitForMultipleObjectsEx() call will timeout right away - * anyway. - * - * Modification for QEMU: replaced timeout >= 10 by timeout > 0. - */ - if (retval == 0 && (timeout == INFINITE || timeout > 0)) { - retval = poll_rest(poll_msgs, handles, nhandles, - fds, nfds, timeout); - } - } else { - /* Just polling for one thing, so no need to check first if - * available immediately - */ - retval = poll_rest(poll_msgs, handles, nhandles, fds, nfds, timeout); - } - - if (retval == -1) { - for (f = fds; f < &fds[nfds]; ++f) { - f->revents = 0; - } - } - - return retval; -} - size_t getpagesize(void) { SYSTEM_INFO system_info; diff --git a/qemu/util/qemu-option.c b/qemu/util/qemu-option.c index 28d6b364..47b7d2f4 100644 --- a/qemu/util/qemu-option.c +++ b/qemu/util/qemu-option.c @@ -288,9 +288,9 @@ QemuOpt *qemu_opt_find(QemuOpts *opts, const char *name) static void qemu_opt_del(QemuOpt *opt) { QTAILQ_REMOVE(&opt->opts->head, opt, next); - g_free(opt->name); - g_free(opt->str); - g_free(opt); + free(opt->name); + free(opt->str); + free(opt); } /* qemu_opt_set allows many settings for the same option. @@ -327,7 +327,7 @@ const char *qemu_opt_get(QemuOpts *opts, const char *name) /* Get a known option (or its default) and remove it from the list * all in one action. Return a malloced string of the option value. - * Result must be freed by caller with g_free(). + * Result must be freed by caller with free(). */ char *qemu_opt_get_del(QemuOpts *opts, const char *name) { @@ -576,7 +576,7 @@ int qemu_opt_set_bool(QemuOpts *opts, const char *name, bool val) opt->desc = find_desc_by_name(desc, name); if (!opt->desc && !opts_accepts_any(opts)) { qerror_report(QERR_INVALID_PARAMETER, name); - g_free(opt); + free(opt); return -1; } @@ -598,7 +598,7 @@ int qemu_opt_set_number(QemuOpts *opts, const char *name, int64_t val) opt->desc = find_desc_by_name(desc, name); if (!opt->desc && !opts_accepts_any(opts)) { qerror_report(QERR_INVALID_PARAMETER, name); - g_free(opt); + free(opt); return -1; } @@ -698,7 +698,7 @@ const char *qemu_opts_id(QemuOpts *opts) return opts->id; } -/* The id string will be g_free()d by qemu_opts_del */ +/* The id string will be free()d by qemu_opts_del */ void qemu_opts_set_id(QemuOpts *opts, char *id) { opts->id = id; @@ -719,8 +719,8 @@ void qemu_opts_del(QemuOpts *opts) qemu_opt_del(opt); } QTAILQ_REMOVE(&opts->list->head, opts, next); - g_free(opts->id); - g_free(opts); + free(opts->id); + free(opts); } void qemu_opts_print(QemuOpts *opts) @@ -1064,7 +1064,7 @@ static size_t count_opts_list(QemuOptsList *list) void qemu_opts_free(QemuOptsList *list) { - g_free(list); + free(list); } /* Realloc dst option list and append options from an option list (list) diff --git a/qemu/util/qemu-thread-win32.c b/qemu/util/qemu-thread-win32.c index 97ba69c6..8ee8826f 100644 --- a/qemu/util/qemu-thread-win32.c +++ b/qemu/util/qemu-thread-win32.c @@ -277,7 +277,7 @@ static unsigned __stdcall win32_start_routine(void *arg) if (data->mode == QEMU_THREAD_DETACHED) { data->uc->qemu_thread_data = NULL; - g_free(data); + free(data); data = NULL; } qemu_thread_exit(data->uc, start_routine(thread_arg)); @@ -323,7 +323,7 @@ void *qemu_thread_join(QemuThread *thread) ret = data->ret; assert(data->mode != QEMU_THREAD_DETACHED); DeleteCriticalSection(&data->cs); - g_free(data); + free(data); return ret; } diff --git a/qemu/vl.c b/qemu/vl.c index d25c8888..b9656f6c 100644 --- a/qemu/vl.c +++ b/qemu/vl.c @@ -168,5 +168,5 @@ void qemu_register_machine(struct uc_struct *uc, QEMUMachine *m, const char *typ ti.class_init = machine_class_init; type_register(uc, &ti); - g_free(name); + free(name); } diff --git a/qemu/x86_64.h b/qemu/x86_64.h index 32d1be77..7e5c9580 100644 --- a/qemu/x86_64.h +++ b/qemu/x86_64.h @@ -2179,15 +2179,12 @@ #define object_property_find object_property_find_x86_64 #define object_property_get object_property_get_x86_64 #define object_property_get_bool object_property_get_bool_x86_64 -#define object_property_get_enum object_property_get_enum_x86_64 #define object_property_get_int object_property_get_int_x86_64 #define object_property_get_link object_property_get_link_x86_64 #define object_property_get_qobject object_property_get_qobject_x86_64 #define object_property_get_str object_property_get_str_x86_64 #define object_property_get_type object_property_get_type_x86_64 -#define object_property_get_uint16List object_property_get_uint16List_x86_64 #define object_property_is_child object_property_is_child_x86_64 -#define object_property_print object_property_print_x86_64 #define object_property_set object_property_set_x86_64 #define object_property_set_description object_property_set_description_x86_64 #define object_property_set_link object_property_set_link_x86_64 @@ -2427,7 +2424,6 @@ #define qemu_get_cpu qemu_get_cpu_x86_64 #define qemu_get_guest_memory_mapping qemu_get_guest_memory_mapping_x86_64 #define qemu_get_guest_simple_memory_mapping qemu_get_guest_simple_memory_mapping_x86_64 -#define qemu_get_local_state_pathname qemu_get_local_state_pathname_x86_64 #define qemu_get_ram_block qemu_get_ram_block_x86_64 #define qemu_get_ram_block_host_ptr qemu_get_ram_block_host_ptr_x86_64 #define qemu_get_ram_fd qemu_get_ram_fd_x86_64 @@ -2716,13 +2712,6 @@ #define string_input_get_visitor string_input_get_visitor_x86_64 #define string_input_visitor_cleanup string_input_visitor_cleanup_x86_64 #define string_input_visitor_new string_input_visitor_new_x86_64 -#define string_output_append string_output_append_x86_64 -#define string_output_append_range string_output_append_range_x86_64 -#define string_output_get_string string_output_get_string_x86_64 -#define string_output_get_visitor string_output_get_visitor_x86_64 -#define string_output_set string_output_set_x86_64 -#define string_output_visitor_cleanup string_output_visitor_cleanup_x86_64 -#define string_output_visitor_new string_output_visitor_new_x86_64 #define stristart stristart_x86_64 #define strongarm_cp_reginfo strongarm_cp_reginfo_x86_64 #define strpadcpy strpadcpy_x86_64 diff --git a/samples/Makefile b/samples/Makefile index b556cb00..da49f5a4 100644 --- a/samples/Makefile +++ b/samples/Makefile @@ -5,11 +5,6 @@ include ../config.mk UNAME_S := $(shell uname -s) -# Find GLIB -ifndef GLIB -GLIB = $(shell pkg-config --libs glib-2.0) -endif - LIBDIR = .. BIN_EXT = AR_EXT = a @@ -18,8 +13,8 @@ AR_EXT = a V ?= 0 CFLAGS += -Wall -Werror -I../include -LDFLAGS += -L$(LIBDIR) -lunicorn -lpthread -lm $(GLIB) -LDLIBS += -lpthread -lunicorn -lm $(GLIB) +LDFLAGS += -L$(LIBDIR) -lunicorn -lpthread -lm +LDLIBS += -lpthread -lunicorn -lm ifneq ($(CROSS),) CC = $(CROSS)gcc diff --git a/tests/regress/Makefile b/tests/regress/Makefile index f9ff4a8b..431cdf32 100644 --- a/tests/regress/Makefile +++ b/tests/regress/Makefile @@ -1,5 +1,5 @@ CFLAGS += -Wall -Werror -I../../include -LDLIBS += -L../../ $(shell pkg-config --libs glib-2.0) -lpthread -lm -lunicorn +LDLIBS += -L../../ -lpthread -lm -lunicorn EXECUTE_VARS = LD_LIBRARY_PATH=../../cmocka/src:../../ DYLD_LIBRARY_PATH=../../ diff --git a/uc.c b/uc.c index 10ebdb6a..5aba88af 100644 --- a/uc.c +++ b/uc.c @@ -28,10 +28,10 @@ static void free_table(gpointer key, gpointer value, gpointer data) { TypeInfo *ti = (TypeInfo*) value; - g_free((void*) ti->class); - g_free((void*) ti->name); - g_free((void*) ti->parent); - g_free((void*) ti); + free((void*) ti->class); + free((void*) ti->name); + free((void*) ti->parent); + free((void*) ti); } UNICORN_EXPORT @@ -287,12 +287,12 @@ uc_err uc_close(uc_engine *uc) // Cleanup internally. if (uc->release) uc->release(uc->tcg_ctx); - g_free(uc->tcg_ctx); + free(uc->tcg_ctx); // Cleanup CPU. - g_free(uc->cpu->tcg_as_listener); - g_free(uc->cpu->thread); - g_free(uc->cpu->halt_cond); + free(uc->cpu->tcg_as_listener); + free(uc->cpu->thread); + free(uc->cpu->halt_cond); // Cleanup all objects. OBJECT(uc->machine_state->accelerator)->ref = 1; @@ -309,7 +309,7 @@ uc_err uc_close(uc_engine *uc) object_unref(uc, OBJECT(uc->root)); // System memory. - g_free(uc->system_memory); + free(uc->system_memory); // Thread relateds. if (uc->qemu_thread_data)