mirror of
https://github.com/yuzu-emu/unicorn
synced 2024-11-25 15:19:00 +00:00
e096e62127
There's no reason to do two malloc's for a flat union; let's just inline the branch struct directly into the C union branch of the flat union. Surprisingly, fewer clients were actually using explicit references to the branch types in comparison to the number of flat unions thus modified. This lets us reduce the hack in qapi-types:gen_variants() added in the previous patch; we no longer need to distinguish between alternates and flat unions. The change to unboxed structs means that u.data (added in commit cee2dedb) is now coincident with random fields of each branch of the flat union, whereas beforehand it was only coincident with pointers (since all branches of a flat union have to be objects). Note that this was already the case for simple unions - but there we got lucky. Remember, visit_start_union() blindly returns true for all visitors except for the dealloc visitor, where it returns the value !!obj->u.data, and that this result then controls whether to proceed with the visit to the variant. Pre-patch, this meant that flat unions were testing whether the boxed pointer was still NULL, and thereby skipping visit_end_implicit_struct() and avoiding a NULL dereference if the pointer had not been allocated. The same was true for simple unions where the current branch had pointer type, except there we bypassed visit_type_FOO(). But for simple unions where the current branch had scalar type, the contents of that scalar meant that the decision to call visit_type_FOO() was data-dependent - the reason we got lucky there is that visit_type_FOO() for all scalar types in the dealloc visitor is a no-op (only the pointer variants had anything to free), so it did not matter whether the dealloc visit was skipped. But with this patch, we would risk leaking memory if we could skip a call to visit_type_FOO_fields() based solely on a data-dependent decision. But notice: in the dealloc visitor, visit_type_FOO() already handles a NULL obj - it was only the visit_type_implicit_FOO() that was failing to check for NULL. And now that we have refactored things to have the branch be part of the parent struct, we no longer have a separate pointer that can be NULL in the first place. So we can just delete the call to visit_start_union() altogether, and blindly visit the branch type; there is no change in behavior except to the dealloc visitor, where we now unconditionally visit the branch, but where that visit is now always safe (for a flat union, we can no longer dereference NULL, and for a simple union, visit_type_FOO() was already safely handling NULL on pointer types). Unfortunately, simple unions are not as easy to switch to unboxed layout; because we are special-casing the hidden implicit type with a single 'data' member, we really DO need to keep calling another layer of visit_start_struct(), with a second malloc; although there are some cleanups planned for simple unions in later patches. visit_start_union() and gen_visit_implicit_struct() are now unused. Drop them. Note that after this patch, the only remaining use of visit_start_implicit_struct() is for alternate types; the next patch will do further cleanup based on that fact. Backports commit 544a3731591f5d53e15f22de00ce5ac758d490b3 from qemu
82 lines
3.2 KiB
C
82 lines
3.2 KiB
C
/*
|
|
* Core Definitions for QAPI Visitor Classes
|
|
*
|
|
* Copyright IBM, Corp. 2011
|
|
*
|
|
* Authors:
|
|
* Anthony Liguori <aliguori@us.ibm.com>
|
|
*
|
|
* 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 QAPI_VISITOR_CORE_H
|
|
#define QAPI_VISITOR_CORE_H
|
|
|
|
#include "qemu/typedefs.h"
|
|
#include "qapi/qmp/qobject.h"
|
|
#include "qapi/error.h"
|
|
#include <stdlib.h>
|
|
|
|
typedef struct GenericList
|
|
{
|
|
union {
|
|
void *value;
|
|
uint64_t padding;
|
|
};
|
|
struct GenericList *next;
|
|
} GenericList;
|
|
|
|
void visit_start_struct(Visitor *v, const char *name, void **obj,
|
|
size_t size, Error **errp);
|
|
void visit_end_struct(Visitor *v, Error **errp);
|
|
void visit_start_implicit_struct(Visitor *v, void **obj, size_t size,
|
|
Error **errp);
|
|
void visit_end_implicit_struct(Visitor *v);
|
|
void visit_start_list(Visitor *v, const char *name, Error **errp);
|
|
GenericList *visit_next_list(Visitor *v, GenericList **list);
|
|
void visit_end_list(Visitor *v);
|
|
|
|
/**
|
|
* Check if an optional member @name of an object needs visiting.
|
|
* For input visitors, set *@present according to whether the
|
|
* corresponding visit_type_*() needs calling; for other visitors,
|
|
* leave *@present unchanged. Return *@present for convenience.
|
|
*/
|
|
bool visit_optional(Visitor *v, const char *name, bool *present);
|
|
|
|
/**
|
|
* Determine the qtype of the item @name in the current object visit.
|
|
* For input visitors, set *@type to the correct qtype of a qapi
|
|
* alternate type; for other visitors, leave *@type unchanged.
|
|
* If @promote_int, treat integers as QTYPE_FLOAT.
|
|
*/
|
|
void visit_get_next_type(Visitor *v, const char *name, QType *type,
|
|
bool promote_int, Error **errp);
|
|
void visit_type_enum(Visitor *v, const char *name, int *obj,
|
|
const char *const strings[], Error **errp);
|
|
void visit_type_int(Visitor *v, const char *name, int64_t *obj, Error **errp);
|
|
void visit_type_uint8(Visitor *v, const char *name, uint8_t *obj,
|
|
Error **errp);
|
|
void visit_type_uint16(Visitor *v, const char *name, uint16_t *obj,
|
|
Error **errp);
|
|
void visit_type_uint32(Visitor *v, const char *name, uint32_t *obj,
|
|
Error **errp);
|
|
void visit_type_uint64(Visitor *v, const char *name, uint64_t *obj,
|
|
Error **errp);
|
|
void visit_type_int8(Visitor *v, const char *name, int8_t *obj, Error **errp);
|
|
void visit_type_int16(Visitor *v, const char *name, int16_t *obj,
|
|
Error **errp);
|
|
void visit_type_int32(Visitor *v, const char *name, int32_t *obj,
|
|
Error **errp);
|
|
void visit_type_int64(Visitor *v, const char *name, int64_t *obj,
|
|
Error **errp);
|
|
void visit_type_size(Visitor *v, const char *name, uint64_t *obj,
|
|
Error **errp);
|
|
void visit_type_bool(Visitor *v, const char *name, bool *obj, Error **errp);
|
|
void visit_type_str(Visitor *v, const char *name, char **obj, Error **errp);
|
|
void visit_type_number(Visitor *v, const char *name, double *obj,
|
|
Error **errp);
|
|
void visit_type_any(Visitor *v, const char *name, QObject **obj, Error **errp);
|
|
|
|
#endif
|