CTF float/types compile fixes
[babeltrace.git] / include / babeltrace / types.h
CommitLineData
d79865b9
MD
1#ifndef _BABELTRACE_TYPES_H
2#define _BABELTRACE_TYPES_H
3
4/*
5 * BabelTrace
6 *
fc93b2bd 7 * Type Header
d79865b9 8 *
c054553d 9 * Copyright 2010, 2011 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
d79865b9 10 *
ccd7e1c8
MD
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:
d79865b9 17 *
ccd7e1c8
MD
18 * The above copyright notice and this permission notice shall be included in
19 * all copies or substantial portions of the Software.
d79865b9
MD
20 */
21
bed864a7 22#include <babeltrace/align.h>
d65d8abb 23#include <babeltrace/list.h>
4c8bfb7e
MD
24#include <stdbool.h>
25#include <stdint.h>
26#include <limits.h>
bed864a7 27#include <string.h>
4c8bfb7e 28#include <glib.h>
8eab883c 29#include <assert.h>
bed864a7 30
11796b96
MD
31/* Preallocate this many fields for structures */
32#define DEFAULT_NR_STRUCT_FIELDS 8
33
bed864a7
MD
34/*
35 * Always update stream_pos with move_pos and init_pos.
36 */
37struct stream_pos {
47e0f2e2 38 char *base; /* Base address */
bed864a7
MD
39 size_t offset; /* Offset from base, in bits */
40 int dummy; /* Dummy position, for length calculation */
41};
42
43static inline
47e0f2e2 44void init_pos(struct stream_pos *pos, char *base)
bed864a7
MD
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 */
56static inline
57void 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 */
67static inline
68void align_pos(struct stream_pos *pos, size_t offset)
69{
70 pos->offset += offset_align(pos->offset, offset);
71}
72
73static inline
74void copy_pos(struct stream_pos *dest, struct stream_pos *src)
75{
76 memcpy(dest, src, sizeof(struct stream_pos));
77}
78
79static inline
47e0f2e2 80char *get_pos_addr(struct stream_pos *pos)
bed864a7
MD
81{
82 /* Only makes sense to get the address after aligning on CHAR_BIT */
4c8bfb7e 83 assert(!(pos->offset % CHAR_BIT));
bed864a7
MD
84 return pos->base + (pos->offset / CHAR_BIT);
85}
fc93b2bd 86
4c8bfb7e 87struct format;
c054553d 88struct type;
4c8bfb7e 89
6b71274a
MD
90/* Type declaration scope */
91struct declaration_scope {
92 /* Hash table mapping type name GQuark to struct type_class */
93 GHashTable *type_classes;
94 struct declaration_scope *parent_scope;
95};
96
fc93b2bd
MD
97struct type_class {
98 GQuark name; /* type name */
99 size_t alignment; /* type alignment, in bits */
c054553d 100 int ref; /* number of references to the type class */
fc93b2bd 101 /*
c054553d
MD
102 * class_free called with type class ref is decremented to 0.
103 */
104 void (*class_free)(struct type_class *type_class);
105 struct type *(*type_new)(struct type_class *_class,
106 struct declaration_scope *parent_scope);
107 /*
108 * type_free called with type ref is decremented to 0.
109 */
110 void (*type_free)(struct type *type);
111 /*
112 * Type copy function. Knows how to find the child type from the parent
113 * type.
fc93b2bd 114 */
4c8bfb7e
MD
115 void (*copy)(struct stream_pos *dest, const struct format *fdest,
116 struct stream_pos *src, const struct format *fsrc,
c054553d
MD
117 struct type *type);
118};
119
120struct type {
121 struct type_class *_class;
122 int ref; /* number of references to the type instance */
fc93b2bd
MD
123};
124
bed864a7
MD
125/*
126 * Because we address in bits, bitfields end up being exactly the same as
127 * integers, except that their read/write functions must be able to deal with
128 * read/write non aligned on CHAR_BIT.
129 */
7fe00194
MD
130struct type_class_integer {
131 struct type_class p;
132 size_t len; /* length, in bits. */
133 int byte_order; /* byte order */
134 int signedness;
fc93b2bd
MD
135};
136
c054553d
MD
137struct type_integer {
138 struct type p;
139 struct type_class_integer *_class;
140 /* Last values read */
141 union {
142 uint64_t _unsigned;
143 int64_t _signed;
144 } value;
145};
146
fc93b2bd
MD
147struct type_class_float {
148 struct type_class p;
4c8bfb7e
MD
149 struct type_class_integer *sign;
150 struct type_class_integer *mantissa;
151 struct type_class_integer *exp;
fc93b2bd 152 int byte_order;
0a46062b 153 /* TODO: we might want to express more info about NaN, +inf and -inf */
fc93b2bd
MD
154};
155
c054553d
MD
156struct type_float {
157 struct type p;
158 struct type_class_float *_class;
159 /* Last values read */
160 long double value;
161};
162
d65d8abb
MD
163/*
164 * enum_val_equal assumes that signed and unsigned memory layout overlap.
165 */
166struct enum_range {
167 union {
168 int64_t _signed;
169 uint64_t _unsigned;
170 } start; /* lowest range value */
171 union {
172 int64_t _signed;
173 uint64_t _unsigned;
174 } end; /* highest range value */
175};
176
177struct enum_range_to_quark {
178 struct cds_list_head node;
179 struct enum_range range;
180 GQuark quark;
181};
182
183/*
184 * We optimize the common case (range of size 1: single value) by creating a
185 * hash table mapping values to quark sets. We then lookup the ranges to
186 * complete the quark set.
187 *
188 * TODO: The proper structure to hold the range to quark set mapping would be an
189 * interval tree, with O(n) size, O(n*log(n)) build time and O(log(n)) query
190 * time. Using a simple O(n) list search for now for implementation speed and
191 * given that we can expect to have a _relatively_ small number of enumeration
192 * ranges. This might become untrue if we are fed with symbol tables often
193 * required to lookup function names from instruction pointer value.
194 */
448d3cc7 195struct enum_table {
d65d8abb
MD
196 GHashTable *value_to_quark_set; /* (value, GQuark GArray) */
197 struct cds_list_head range_to_quark; /* (range, GQuark) */
198 GHashTable *quark_to_range_set; /* (GQuark, range GArray) */
448d3cc7
MD
199};
200
fc93b2bd 201struct type_class_enum {
4c8bfb7e 202 struct type_class_integer p; /* inherit from integer */
448d3cc7 203 struct enum_table table;
fc93b2bd
MD
204};
205
c054553d
MD
206struct type_enum {
207 struct type p;
208 struct type_class_enum *_class;
209 /* Last GQuark values read. Keeping a reference on the GQuark array. */
210 GArray *value;
211};
212
bed864a7
MD
213struct type_class_string {
214 struct type_class p;
215};
216
c054553d
MD
217struct type_string {
218 struct type p;
219 struct type_class_string *_class;
220 char *value; /* freed at type_string teardown */
221};
222
223struct type_class_field {
11796b96
MD
224 GQuark name;
225 struct type_class *type_class;
226};
227
c054553d
MD
228struct field {
229 struct type *type;
230};
231
fc93b2bd
MD
232struct type_class_struct {
233 struct type_class p;
11796b96 234 GHashTable *fields_by_name; /* Tuples (field name, field index) */
c054553d
MD
235 GArray *fields; /* Array of type_class_field */
236};
237
238struct type_struct {
239 struct type p;
240 struct type_class_struct *_class;
241 struct declaration_scope *scope;
242 GArray *fields; /* Array of struct field */
243};
244
245struct type_class_variant {
246 struct type_class p;
247 GHashTable *fields_by_tag; /* Tuples (field tag, field index) */
248 GArray *fields; /* Array of type_class_field */
249};
250
251struct type_variant {
252 struct type p;
253 struct type_class_variant *_class;
254 struct declaration_scope *scope;
255 struct type *tag;
256 GArray *fields; /* Array of struct field */
257 struct field *current_field; /* Last field read */
11796b96
MD
258};
259
260struct type_class_array {
261 struct type_class p;
262 size_t len;
263 struct type_class *elem;
264};
265
c054553d
MD
266struct type_array {
267 struct type p;
268 struct type_class_array *_class;
269 struct declaration_scope *scope;
270 struct field current_element; /* struct field */
271};
272
11796b96
MD
273struct type_class_sequence {
274 struct type_class p;
2e7d72cf 275 struct type_class_integer *len_class;
11796b96 276 struct type_class *elem;
fc93b2bd
MD
277};
278
c054553d
MD
279struct type_sequence {
280 struct type p;
281 struct type_class_sequence *_class;
282 struct declaration_scope *scope;
283 struct type_integer *len;
284 struct field current_element; /* struct field */
285};
286
c054553d
MD
287struct type_class *lookup_type_class(GQuark qname,
288 struct declaration_scope *scope);
289int register_type_class(struct type_class *type_class,
290 struct declaration_scope *scope);
291
292void type_class_ref(struct type_class *type_class);
293void type_class_unref(struct type_class *type_class);
294
295struct declaration_scope *
296new_declaration_scope(struct declaration_scope *parent_scope);
297void free_declaration_scope(struct declaration_scope *scope);
4c8bfb7e 298
c054553d
MD
299void type_ref(struct type *type);
300void type_unref(struct type *type);
698f0fe4 301
0a46062b
MD
302/* Nameless types can be created by passing a NULL name */
303
c054553d 304struct type_class_integer *integer_type_class_new(const char *name,
0a46062b 305 size_t len, int byte_order,
11d43b90
MD
306 int signedness,
307 size_t alignment);
0a46062b 308
11d43b90
MD
309/*
310 * mantissa_len is the length of the number of bytes represented by the mantissa
311 * (e.g. result of DBL_MANT_DIG). It includes the leading 1.
312 */
c054553d 313struct type_class_float *float_type_class_new(const char *name,
0a46062b
MD
314 size_t mantissa_len,
315 size_t exp_len, int byte_order,
316 size_t alignment);
0a46062b 317
448d3cc7
MD
318/*
319 * A GQuark can be translated to/from strings with g_quark_from_string() and
320 * g_quark_to_string().
321 */
47e0f2e2
MD
322
323/*
324 * Returns a GArray of GQuark or NULL.
325 * Caller must release the GArray with g_array_unref().
326 */
d65d8abb
MD
327GArray *enum_uint_to_quark_set(const struct type_class_enum *enum_class,
328 uint64_t v);
329
330/*
47e0f2e2 331 * Returns a GArray of GQuark or NULL.
d65d8abb
MD
332 * Caller must release the GArray with g_array_unref().
333 */
334GArray *enum_int_to_quark_set(const struct type_class_enum *enum_class,
335 uint64_t v);
47e0f2e2
MD
336
337/*
338 * Returns a GArray of struct enum_range or NULL.
fdacfb73
MD
339 * Callers do _not_ own the returned GArray (and therefore _don't_ need to
340 * release it).
47e0f2e2 341 */
d65d8abb
MD
342GArray *enum_quark_to_range_set(const struct type_class_enum *enum_class,
343 GQuark q);
448d3cc7 344void enum_signed_insert(struct type_class_enum *enum_class,
d65d8abb 345 int64_t start, int64_t end, GQuark q);
448d3cc7 346void enum_unsigned_insert(struct type_class_enum *enum_class,
d65d8abb 347 uint64_t start, uint64_t end, GQuark q);
c054553d 348size_t enum_get_nr_enumerators(struct type_class_enum *enum_class);
448d3cc7 349
c054553d 350struct type_class_enum *enum_type_class_new(const char *name,
448d3cc7
MD
351 size_t len, int byte_order,
352 int signedness,
353 size_t alignment);
448d3cc7 354
c054553d
MD
355struct type_class_struct *struct_type_class_new(const char *name);
356void struct_type_class_add_field(struct type_class_struct *struct_class,
357 const char *field_name,
358 struct type_class *type_class);
11796b96
MD
359/*
360 * Returns the index of a field within a structure.
361 */
362unsigned long
c054553d
MD
363struct_type_class_lookup_field_index(struct type_class_struct *struct_class,
364 GQuark field_name);
11796b96
MD
365/*
366 * field returned only valid as long as the field structure is not appended to.
367 */
c054553d
MD
368struct type_class_field *
369struct_type_class_get_field_from_index(struct type_class_struct *struct_class,
370 unsigned long index);
11796b96 371struct field *
c054553d 372struct_type_get_field_from_index(struct type_struct *_struct,
11796b96
MD
373 unsigned long index);
374
c054553d
MD
375/*
376 * The tag enumeration is validated to ensure that it contains only mappings
377 * from numeric values to a single tag. Overlapping tag value ranges are
378 * therefore forbidden.
379 */
380struct type_class_variant *variant_type_class_new(const char *name);
381void variant_type_class_add_field(struct type_class_variant *variant_class,
382 const char *tag_name,
383 struct type_class *type_class);
384struct type_class_field *
385variant_type_class_get_field_from_tag(struct type_class_variant *variant_class,
386 GQuark tag);
387/*
388 * Returns 0 on success, -EPERM on error.
389 */
390int variant_type_set_tag(struct type_variant *variant,
391 struct type *enum_tag_instance);
392/*
393 * Returns the field selected by the current tag value.
394 * field returned only valid as long as the variant structure is not appended
395 * to.
396 */
397struct field *
398variant_type_get_current_field(struct type_variant *variant);
399
d06d03db
MD
400/*
401 * elem_class passed as parameter now belongs to the array. No need to free it
c054553d 402 * explicitly. "len" is the number of elements in the array.
d06d03db 403 */
c054553d 404struct type_class_array *array_type_class_new(const char *name,
11796b96
MD
405 size_t len,
406 struct type_class *elem_class);
11796b96 407
d06d03db
MD
408/*
409 * int_class and elem_class passed as parameter now belongs to the sequence. No
c054553d 410 * need to free them explicitly.
d06d03db 411 */
c054553d 412struct type_class_sequence *sequence_type_class_new(const char *name,
2e7d72cf 413 struct type_class_integer *len_class,
11796b96 414 struct type_class *elem_class);
11796b96 415
d79865b9 416#endif /* _BABELTRACE_TYPES_H */
This page took 0.039678 seconds and 4 git commands to generate.