Update g array ref
[babeltrace.git] / include / babeltrace / types.h
1 #ifndef _BABELTRACE_TYPES_H
2 #define _BABELTRACE_TYPES_H
3
4 /*
5 * BabelTrace
6 *
7 * Type Header
8 *
9 * Copyright 2010 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
10 *
11 * Permission is hereby granted, free of charge, to any person obtaining a copy
12 * of this software and associated documentation files (the "Software"), to deal
13 * in the Software without restriction, including without limitation the rights
14 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
15 * copies of the Software, and to permit persons to whom the Software is
16 * furnished to do so, subject to the following conditions:
17 *
18 * The above copyright notice and this permission notice shall be included in
19 * all copies or substantial portions of the Software.
20 */
21
22 #include <babeltrace/align.h>
23 #include <babeltrace/list.h>
24 #include <stdbool.h>
25 #include <stdint.h>
26 #include <limits.h>
27 #include <string.h>
28 #include <glib.h>
29 #include <assert.h>
30
31 /* Preallocate this many fields for structures */
32 #define DEFAULT_NR_STRUCT_FIELDS 8
33
34 /*
35 * Always update stream_pos with move_pos and init_pos.
36 */
37 struct stream_pos {
38 char *base; /* Base address */
39 size_t offset; /* Offset from base, in bits */
40 int dummy; /* Dummy position, for length calculation */
41 };
42
43 static inline
44 void init_pos(struct stream_pos *pos, char *base)
45 {
46 pos->base = base; /* initial base, page-aligned */
47 pos->offset = 0;
48 pos->dummy = false;
49 }
50
51 /*
52 * move_pos - move position of a relative bit offset
53 *
54 * TODO: allow larger files by updating base too.
55 */
56 static inline
57 void move_pos(struct stream_pos *pos, size_t offset)
58 {
59 pos->offset = pos->offset + offset;
60 }
61
62 /*
63 * align_pos - align position on a bit offset (> 0)
64 *
65 * TODO: allow larger files by updating base too.
66 */
67 static inline
68 void align_pos(struct stream_pos *pos, size_t offset)
69 {
70 pos->offset += offset_align(pos->offset, offset);
71 }
72
73 static inline
74 void copy_pos(struct stream_pos *dest, struct stream_pos *src)
75 {
76 memcpy(dest, src, sizeof(struct stream_pos));
77 }
78
79 static inline
80 char *get_pos_addr(struct stream_pos *pos)
81 {
82 /* Only makes sense to get the address after aligning on CHAR_BIT */
83 assert(!(pos->offset % CHAR_BIT));
84 return pos->base + (pos->offset / CHAR_BIT);
85 }
86
87 struct format;
88
89 struct type_class {
90 GQuark name; /* type name */
91 size_t alignment; /* type alignment, in bits */
92 int ref; /* number of references to the type */
93 /*
94 * Type copy function. Knows how to find the child type_class from the
95 * parent type_class.
96 */
97 void (*copy)(struct stream_pos *dest, const struct format *fdest,
98 struct stream_pos *src, const struct format *fsrc,
99 const struct type_class *type_class);
100 void (*free)(struct type_class *type_class);
101 };
102
103 /*
104 * Because we address in bits, bitfields end up being exactly the same as
105 * integers, except that their read/write functions must be able to deal with
106 * read/write non aligned on CHAR_BIT.
107 */
108 struct type_class_integer {
109 struct type_class p;
110 size_t len; /* length, in bits. */
111 int byte_order; /* byte order */
112 int signedness;
113 };
114
115 struct type_class_float {
116 struct type_class p;
117 struct type_class_integer *sign;
118 struct type_class_integer *mantissa;
119 struct type_class_integer *exp;
120 int byte_order;
121 /* TODO: we might want to express more info about NaN, +inf and -inf */
122 };
123
124 /*
125 * enum_val_equal assumes that signed and unsigned memory layout overlap.
126 */
127 struct enum_range {
128 union {
129 int64_t _signed;
130 uint64_t _unsigned;
131 } start; /* lowest range value */
132 union {
133 int64_t _signed;
134 uint64_t _unsigned;
135 } end; /* highest range value */
136 };
137
138 struct enum_range_to_quark {
139 struct cds_list_head node;
140 struct enum_range range;
141 GQuark quark;
142 };
143
144 /*
145 * We optimize the common case (range of size 1: single value) by creating a
146 * hash table mapping values to quark sets. We then lookup the ranges to
147 * complete the quark set.
148 *
149 * TODO: The proper structure to hold the range to quark set mapping would be an
150 * interval tree, with O(n) size, O(n*log(n)) build time and O(log(n)) query
151 * time. Using a simple O(n) list search for now for implementation speed and
152 * given that we can expect to have a _relatively_ small number of enumeration
153 * ranges. This might become untrue if we are fed with symbol tables often
154 * required to lookup function names from instruction pointer value.
155 */
156 struct enum_table {
157 GHashTable *value_to_quark_set; /* (value, GQuark GArray) */
158 struct cds_list_head range_to_quark; /* (range, GQuark) */
159 GHashTable *quark_to_range_set; /* (GQuark, range GArray) */
160 };
161
162 struct type_class_enum {
163 struct type_class_integer p; /* inherit from integer */
164 struct enum_table table;
165 };
166
167 struct type_class_string {
168 struct type_class p;
169 };
170
171 struct field {
172 GQuark name;
173 struct type_class *type_class;
174 };
175
176 struct type_class_struct {
177 struct type_class p;
178 GHashTable *fields_by_name; /* Tuples (field name, field index) */
179 GArray *fields; /* Array of fields */
180 };
181
182 struct type_class_array {
183 struct type_class p;
184 size_t len;
185 struct type_class *elem;
186 };
187
188 struct type_class_sequence {
189 struct type_class p;
190 struct type_class_integer *len_class;
191 struct type_class *elem;
192 };
193
194 struct type_class *lookup_type(GQuark qname);
195 int register_type(struct type_class *type_class);
196
197 void type_ref(struct type_class *type_class);
198 void type_unref(struct type_class *type_class);
199
200 /* Nameless types can be created by passing a NULL name */
201
202 struct type_class_integer *integer_type_new(const char *name,
203 size_t len, int byte_order,
204 int signedness,
205 size_t alignment);
206 void integer_type_free(struct type_class_integer *int_class);
207
208 /*
209 * mantissa_len is the length of the number of bytes represented by the mantissa
210 * (e.g. result of DBL_MANT_DIG). It includes the leading 1.
211 */
212 struct type_class_float *float_type_new(const char *name,
213 size_t mantissa_len,
214 size_t exp_len, int byte_order,
215 size_t alignment);
216 void float_type_free(struct type_class_float *float_class);
217
218 /*
219 * A GQuark can be translated to/from strings with g_quark_from_string() and
220 * g_quark_to_string().
221 */
222
223 /*
224 * Returns a GArray of GQuark or NULL.
225 * Caller must release the GArray with g_array_unref().
226 */
227 GArray *enum_uint_to_quark_set(const struct type_class_enum *enum_class,
228 uint64_t v);
229
230 /*
231 * Returns a GArray of GQuark or NULL.
232 * Caller must release the GArray with g_array_unref().
233 */
234 GArray *enum_int_to_quark_set(const struct type_class_enum *enum_class,
235 uint64_t v);
236
237 /*
238 * Returns a GArray of struct enum_range or NULL.
239 * Callers do _not_ own the returned GArray (and therefore _don't_ need to
240 * release it).
241 */
242 GArray *enum_quark_to_range_set(const struct type_class_enum *enum_class,
243 GQuark q);
244 void enum_signed_insert(struct type_class_enum *enum_class,
245 int64_t start, int64_t end, GQuark q);
246 void enum_unsigned_insert(struct type_class_enum *enum_class,
247 uint64_t start, uint64_t end, GQuark q);
248
249 struct type_class_enum *enum_type_new(const char *name,
250 size_t len, int byte_order,
251 int signedness,
252 size_t alignment);
253 void enum_type_free(struct type_class_enum *enum_class);
254
255 struct type_class_struct *struct_type_new(const char *name);
256 void struct_type_free(struct type_class_struct *struct_class);
257 void struct_type_add_field(struct type_class_struct *struct_class,
258 const char *field_name,
259 struct type_class *type_class);
260 /*
261 * Returns the index of a field within a structure.
262 */
263 unsigned long
264 struct_type_lookup_field_index(struct type_class_struct *struct_class,
265 GQuark field_name);
266 /*
267 * field returned only valid as long as the field structure is not appended to.
268 */
269 struct field *
270 struct_type_get_field_from_index(struct type_class_struct *struct_class,
271 unsigned long index);
272
273 /*
274 * elem_class passed as parameter now belongs to the array. No need to free it
275 * explicitely.
276 */
277 struct type_class_array *array_type_new(const char *name,
278 size_t len,
279 struct type_class *elem_class);
280 void array_type_free(struct type_class_array *array_class);
281
282 /*
283 * int_class and elem_class passed as parameter now belongs to the sequence. No
284 * need to free them explicitely.
285 */
286 struct type_class_sequence *sequence_type_new(const char *name,
287 struct type_class_integer *len_class,
288 struct type_class *elem_class);
289 void sequence_type_free(struct type_class_sequence *sequence_class);
290
291 #endif /* _BABELTRACE_TYPES_H */
This page took 0.034511 seconds and 4 git commands to generate.