X-Git-Url: http://git.efficios.com/?p=babeltrace.git;a=blobdiff_plain;f=include%2Fbabeltrace%2Ftypes.h;h=da2387d311853192dbc6885898a10a40505c407f;hp=7da11af24bab4c8e02b9c56f1322afaa45768f0c;hb=6b71274a81b38da08261f2122597c540b02b7aee;hpb=2e7d72cf823b70b03d84e287ae4fda5b9ead7cb5 diff --git a/include/babeltrace/types.h b/include/babeltrace/types.h index 7da11af2..da2387d3 100644 --- a/include/babeltrace/types.h +++ b/include/babeltrace/types.h @@ -6,26 +6,27 @@ * * Type Header * - * Copyright (c) 2010 Mathieu Desnoyers + * Copyright 2010, 2011 - Mathieu Desnoyers * - * 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.1 of the License, or (at your option) any later version. + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: * - * 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, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. */ -#include #include +#include +#include +#include +#include #include +#include +#include /* Preallocate this many fields for structures */ #define DEFAULT_NR_STRUCT_FIELDS 8 @@ -34,13 +35,13 @@ * Always update stream_pos with move_pos and init_pos. */ struct stream_pos { - unsigned char *base; /* Base address */ + char *base; /* Base address */ size_t offset; /* Offset from base, in bits */ int dummy; /* Dummy position, for length calculation */ }; static inline -void init_pos(struct stream_pos *pos, unsigned char *base) +void init_pos(struct stream_pos *pos, char *base) { pos->base = base; /* initial base, page-aligned */ pos->offset = 0; @@ -76,24 +77,49 @@ void copy_pos(struct stream_pos *dest, struct stream_pos *src) } static inline -unsigned char *get_pos_addr(struct stream_pos *pos) +char *get_pos_addr(struct stream_pos *pos) { /* Only makes sense to get the address after aligning on CHAR_BIT */ - assert(!(pos->alignment % CHAR_BIT)); + assert(!(pos->offset % CHAR_BIT)); return pos->base + (pos->offset / CHAR_BIT); } +struct format; +struct type; + +/* Type declaration scope */ +struct declaration_scope { + /* Hash table mapping type name GQuark to struct type_class */ + GHashTable *type_classes; + struct declaration_scope *parent_scope; +}; + struct type_class { GQuark name; /* type name */ size_t alignment; /* type alignment, in bits */ + int ref; /* number of references to the type class */ + /* + * class_free called with type class ref is decremented to 0. + */ + void (*class_free)(struct type_class *type_class); + struct type *(*type_new)(struct type_class *_class, + struct declaration_scope *parent_scope); + /* + * type_free called with type ref is decremented to 0. + */ + void (*type_free)(struct type *type); /* - * Type copy function. Knows how to find the child type_class from the - * parent type_class. + * Type copy function. Knows how to find the child type from the parent + * type. */ - size_t (*copy)(struct stream_pos *dest, const struct format *fdest, - struct stream_pos *src, const struct format *fsrc, - const struct type_class *type_class); - void (*free)(struct type_class *type_class); + void (*copy)(struct stream_pos *dest, const struct format *fdest, + struct stream_pos *src, const struct format *fsrc, + struct type *type); +}; + +struct type { + struct type_class *_class; + int ref; /* number of references to the type instance */ }; /* @@ -108,38 +134,127 @@ struct type_class_integer { int signedness; }; +struct type_integer { + struct type p; + struct type_class_integer *_class; + /* Last values read */ + union { + uint64_t _unsigned; + int64_t _signed; + } value; +}; + struct type_class_float { struct type_class p; - struct int_class *sign; - struct int_class *mantissa; - struct int_class *exp; + struct type_class_integer *sign; + struct type_class_integer *mantissa; + struct type_class_integer *exp; int byte_order; /* TODO: we might want to express more info about NaN, +inf and -inf */ }; +struct type_float { + struct type p; + struct type_class_float *_class; + /* Last values read */ + long double value; +}; + +/* + * enum_val_equal assumes that signed and unsigned memory layout overlap. + */ +struct enum_range { + union { + int64_t _signed; + uint64_t _unsigned; + } start; /* lowest range value */ + union { + int64_t _signed; + uint64_t _unsigned; + } end; /* highest range value */ +}; + +struct enum_range_to_quark { + struct cds_list_head node; + struct enum_range range; + GQuark quark; +}; + +/* + * We optimize the common case (range of size 1: single value) by creating a + * hash table mapping values to quark sets. We then lookup the ranges to + * complete the quark set. + * + * TODO: The proper structure to hold the range to quark set mapping would be an + * interval tree, with O(n) size, O(n*log(n)) build time and O(log(n)) query + * time. Using a simple O(n) list search for now for implementation speed and + * given that we can expect to have a _relatively_ small number of enumeration + * ranges. This might become untrue if we are fed with symbol tables often + * required to lookup function names from instruction pointer value. + */ struct enum_table { - GHashTable *value_to_quark; /* Tuples (value, GQuark) */ - GHashTable *quark_to_value; /* Tuples (GQuark, value) */ + GHashTable *value_to_quark_set; /* (value, GQuark GArray) */ + struct cds_list_head range_to_quark; /* (range, GQuark) */ + GHashTable *quark_to_range_set; /* (GQuark, range GArray) */ }; struct type_class_enum { - struct type_class_int p; /* inherit from integer */ + struct type_class_integer p; /* inherit from integer */ struct enum_table table; }; +struct type_enum { + struct type p; + struct type_class_enum *_class; + /* Last GQuark values read. Keeping a reference on the GQuark array. */ + GArray *value; +}; + struct type_class_string { struct type_class p; }; -struct field { +struct type_string { + struct type p; + struct type_class_string *_class; + char *value; /* freed at type_string teardown */ +}; + +struct type_class_field { GQuark name; struct type_class *type_class; }; +struct field { + struct type *type; +}; + struct type_class_struct { struct type_class p; GHashTable *fields_by_name; /* Tuples (field name, field index) */ - GArray *fields; /* Array of fields */ + GArray *fields; /* Array of type_class_field */ +}; + +struct type_struct { + struct type p; + struct type_class_struct *_class; + struct declaration_scope *scope; + GArray *fields; /* Array of struct field */ +}; + +struct type_class_variant { + struct type_class p; + GHashTable *fields_by_tag; /* Tuples (field tag, field index) */ + GArray *fields; /* Array of type_class_field */ +}; + +struct type_variant { + struct type p; + struct type_class_variant *_class; + struct declaration_scope *scope; + struct type *tag; + GArray *fields; /* Array of struct field */ + struct field *current_field; /* Last field read */ }; struct type_class_array { @@ -148,88 +263,154 @@ struct type_class_array { struct type_class *elem; }; +struct type_array { + struct type p; + struct type_class_array *_class; + struct declaration_scope *scope; + struct field current_element; /* struct field */ +}; + struct type_class_sequence { struct type_class p; struct type_class_integer *len_class; struct type_class *elem; }; -struct type_class *ctf_lookup_type(GQuark qname); -int ctf_register_type(struct type_class *type_class); +struct type_sequence { + struct type p; + struct type_class_sequence *_class; + struct declaration_scope *scope; + struct type_integer *len; + struct field current_element; /* struct field */ +}; + +struct type_class *lookup_type_class(GQuark qname, + struct declaration_scope *scope); +int register_type_class(struct type_class *type_class, + struct declaration_scope *scope); + +void type_class_ref(struct type_class *type_class); +void type_class_unref(struct type_class *type_class); + +struct declaration_scope * +new_declaration_scope(struct declaration_scope *parent_scope); +void free_declaration_scope(struct declaration_scope *scope); + +void type_ref(struct type *type); +void type_unref(struct type *type); /* Nameless types can be created by passing a NULL name */ -struct type_class_integer *integer_type_new(const char *name, +struct type_class_integer *integer_type_class_new(const char *name, size_t len, int byte_order, int signedness, size_t alignment); -void integer_type_free(struct type_class_integer *int_class); /* * mantissa_len is the length of the number of bytes represented by the mantissa * (e.g. result of DBL_MANT_DIG). It includes the leading 1. */ -struct type_class_float *float_type_new(const char *name, +struct type_class_float *float_type_class_new(const char *name, size_t mantissa_len, size_t exp_len, int byte_order, size_t alignment); -void float_type_free(struct type_class_float *float_class); /* * A GQuark can be translated to/from strings with g_quark_from_string() and * g_quark_to_string(). */ -GQuark enum_uint_to_quark(const struct type_class_enum *enum_class, uint64_t v); -GQuark enum_int_to_quark(const struct type_class_enum *enum_class, uint64_t v); -uint64_t enum_quark_to_uint(const struct type_class_enum *enum_class, - size_t len, int byte_order, GQuark q); -int64_t enum_quark_to_int(const struct type_class_enum *enum_class, - size_t len, int byte_order, GQuark q); + +/* + * Returns a GArray of GQuark or NULL. + * Caller must release the GArray with g_array_unref(). + */ +GArray *enum_uint_to_quark_set(const struct type_class_enum *enum_class, + uint64_t v); + +/* + * Returns a GArray of GQuark or NULL. + * Caller must release the GArray with g_array_unref(). + */ +GArray *enum_int_to_quark_set(const struct type_class_enum *enum_class, + uint64_t v); + +/* + * Returns a GArray of struct enum_range or NULL. + * Callers do _not_ own the returned GArray (and therefore _don't_ need to + * release it). + */ +GArray *enum_quark_to_range_set(const struct type_class_enum *enum_class, + GQuark q); void enum_signed_insert(struct type_class_enum *enum_class, - int64_t v, GQuark q); + int64_t start, int64_t end, GQuark q); void enum_unsigned_insert(struct type_class_enum *enum_class, - uint64_t v, GQuark q); + uint64_t start, uint64_t end, GQuark q); +size_t enum_get_nr_enumerators(struct type_class_enum *enum_class); -struct type_class_enum *enum_type_new(const char *name, +struct type_class_enum *enum_type_class_new(const char *name, size_t len, int byte_order, int signedness, size_t alignment); -void enum_type_free(struct type_class_enum *enum_class); -struct type_class_struct *struct_type_new(const char *name); -void struct_type_free(struct type_class_struct *struct_class); -void struct_type_add_field(struct type_class_struct *struct_class, - GQuark field_name, - struct type_class *type_class); +struct type_class_struct *struct_type_class_new(const char *name); +void struct_type_class_add_field(struct type_class_struct *struct_class, + const char *field_name, + struct type_class *type_class); /* * Returns the index of a field within a structure. */ unsigned long -struct_type_lookup_field_index(struct type_class_struct *struct_class, - GQuark field_name); +struct_type_class_lookup_field_index(struct type_class_struct *struct_class, + GQuark field_name); /* * field returned only valid as long as the field structure is not appended to. */ +struct type_class_field * +struct_type_class_get_field_from_index(struct type_class_struct *struct_class, + unsigned long index); struct field * -struct_type_get_field_from_index(struct type_class_struct *struct_class, +struct_type_get_field_from_index(struct type_struct *_struct, unsigned long index); +/* + * The tag enumeration is validated to ensure that it contains only mappings + * from numeric values to a single tag. Overlapping tag value ranges are + * therefore forbidden. + */ +struct type_class_variant *variant_type_class_new(const char *name); +void variant_type_class_add_field(struct type_class_variant *variant_class, + const char *tag_name, + struct type_class *type_class); +struct type_class_field * +variant_type_class_get_field_from_tag(struct type_class_variant *variant_class, + GQuark tag); +/* + * Returns 0 on success, -EPERM on error. + */ +int variant_type_set_tag(struct type_variant *variant, + struct type *enum_tag_instance); +/* + * Returns the field selected by the current tag value. + * field returned only valid as long as the variant structure is not appended + * to. + */ +struct field * +variant_type_get_current_field(struct type_variant *variant); + /* * elem_class passed as parameter now belongs to the array. No need to free it - * explicitely. + * explicitly. "len" is the number of elements in the array. */ -struct type_class_array *array_type_new(const char *name, +struct type_class_array *array_type_class_new(const char *name, size_t len, struct type_class *elem_class); -void array_type_free(struct type_class_array *array_class); /* * int_class and elem_class passed as parameter now belongs to the sequence. No - * need to free them explicitely. + * need to free them explicitly. */ -struct type_class_sequence *sequence_type_new(const char *name, +struct type_class_sequence *sequence_type_class_new(const char *name, struct type_class_integer *len_class, struct type_class *elem_class); -void sequence_type_free(struct type_class_sequence *sequence_class); #endif /* _BABELTRACE_TYPES_H */