From: Mathieu Desnoyers Date: Tue, 28 Sep 2010 14:54:09 +0000 (-0400) Subject: Development tree reorganisation X-Git-Tag: v0.1~238 X-Git-Url: http://git.efficios.com/?p=babeltrace.git;a=commitdiff_plain;h=7172902caa455601e0d7429378e898eb12bbb2ba Development tree reorganisation Separate the "converter" files from the "formats" files, so the converter can deal with multiple formats. Formats will register to the converter as plugins. Signed-off-by: Mathieu Desnoyers --- diff --git a/converter/types.c b/converter/types.c new file mode 100644 index 00000000..f4843e6a --- /dev/null +++ b/converter/types.c @@ -0,0 +1,80 @@ +/* + * Common Trace Format - Converter + * + * Types registry. + * + * Copyright (c) 2010 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. + * + * 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 + */ + +#include +#include +#include + +struct type_class { + GQuark qname; + void (*read)(); + size_t (*write)(); +}; + +struct type { + struct type_class *class; + size_t alignment; /* type alignment, in bits */ + ssize_t len; /* type length, in bits. -1 for dynamic size. */ +}; + +/* + * Type class hash table contains the registered type classes. Type class + * registration is typically performed by a plugin. + * TODO: support plugin unload (unregistration of type classes). + */ +GHashTable *type_classes; + +struct type_class *ctf_lookup_type_class(GQuark qname) +{ + return g_hash_table_lookup(type_classes, + (gconstpointer) (unsigned long) qname) +} + +int ctf_register_type_class(const char *name, + void (*read)(), + void (*write)()) +{ + struct type_class tc = g_new(struct type_class, 1); + GQuark qname = g_quark_from_string(name); + + if (ctf_lookup_type_class(qname)) + return -EEXIST; + + g_hash_table_insert(type_classes, + (gconstpointer) (unsigned long) qname, + tc); + return 0; +} + +int ctf_init_types(void) +{ + type_classes = g_hash_table_new_full(g_direct_hash, g_direct_equal, + NULL, g_free); + if (!type_classes) + return -ENOMEM; + return 0; +} + +int ctf_finalize_types(void) +{ + g_hash_table_destroy(type_classes); +} diff --git a/formats/ctf/types/enum.c b/formats/ctf/types/enum.c new file mode 100644 index 00000000..507d0c35 --- /dev/null +++ b/formats/ctf/types/enum.c @@ -0,0 +1,174 @@ +/* + * Common Trace Format + * + * Enumeration mapping strings (quarks) from/to integers. + * + * Copyright (c) 2010 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. + * + * 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 + */ + +#include +#include +#include + +struct enum_table { + GHashTable *value_to_quark; /* Tuples (value, GQuark) */ + GHashTable *quark_to_value; /* Tuples (GQuark, value) */ +}; + +#if (__WORDSIZE == 32) +GQuark enum_uint_to_quark(const struct enum_table *table, uint64_t v) +{ + gconstpointer q = g_hash_table_lookup(table->value_to_quark, &v); + return (GQuark) (unsigned long) q; +} + +GQuark enum_int_to_quark(const struct enum_table *table, uint64_t v) +{ + gconstpointer q = g_hash_table_lookup(table->value_to_quark, &v); + return (GQuark) (unsigned long) q; +} + +uint64_t enum_quark_to_uint(size_t len, int byte_order, GQuark q) +{ + gconstpointer v = g_hash_table_lookup(table->quark_to_value, + (gconstpointer) q); + return *(const uint64_t *) v; +} + +int64_t enum_quark_to_int(size_t len, int byte_order, GQuark q) +{ + gconstpointer v = g_hash_table_lookup(table->quark_to_value, + (gconstpointer) q); + return *(const int64_t *) v; +} + +guint enum_val_hash(gconstpointer key) +{ + int64_t ukey = *(const int64_t *)key; + + return (guint)ukey ^ (guint)(ukey >> 32); +} + +gboolean enum_val_equal(gconstpointer a, gconstpointer b) +{ + int64_t ua = *(const int64_t *)a; + int64_t ub = *(const int64_t *)b; + + return ua == ub; +} + +void enum_val_free(void *ptr) +{ + g_free(ptr); +} + +void enum_signed_insert(struct enum_table *table, int64_t v, GQuark q) +{ + int64_t *valuep = g_new(int64_t, 1); + + g_hash_table_insert(table->value_to_quark, valuep, + (gpointer) (unsigned long) q); + g_hash_table_insert(table->quark_to_value, (gpointer) (unsigned long) q, + valuep); +} + +void enum_unsigned_insert(struct enum_table *table, uint64_t v, GQuark q) +{ + uint64_t *valuep = g_new(uint64_t, 1); + + g_hash_table_insert(table->value_to_quark, valuep, + (gpointer) (unsigned long) q); + g_hash_table_insert(table->quark_to_value, (gpointer) (unsigned long) q, + valuep); +} +#else /* __WORDSIZE != 32 */ +GQuark enum_uint_to_quark(const struct enum_table *table, uint64_t v) +{ + gconstpointer q = g_hash_table_lookup(table->value_to_quark, + (gconstpointer) v); + return (GQuark) (unsigned long) q; +} + +GQuark enum_int_to_quark(const struct enum_table *table, uint64_t v) +{ + gconstpointer q = g_hash_table_lookup(table->value_to_quark, + (gconstpointer) v); + return (GQuark) (unsigned long) q; +} + +uint64_t enum_quark_to_uint(size_t len, int byte_order, GQuark q) +{ + gconstpointer v = g_hash_table_lookup(table->quark_to_value, + (gconstpointer) (unsigned long) q); + return *(const uint64_t *) v; +} + +int64_t enum_quark_to_int(size_t len, int byte_order, GQuark q) +{ + gconstpointer v = g_hash_table_lookup(table->quark_to_value, + (gconstpointer) (unsigned long) q); + return *(const int64_t *) v; +} + +guint enum_val_hash(gconstpointer key) +{ + return g_direct_hash(key); +} + +gboolean enum_val_equal(gconstpointer a, gconstpointer b) +{ + return g_direct_equal(a, b); +} + +void enum_val_free(void *ptr) +{ +} + +void enum_signed_insert(struct enum_table *table, int64_t v, GQuark q) +{ + g_hash_table_insert(table->value_to_quark, (gpointer) v, + (gpointer) (unsigned long) q); + g_hash_table_insert(table->quark_to_value, (gpointer) (unsigned long) q, + valuep); +} + +void enum_unsigned_insert(struct enum_table *table, uint64_t v, GQuark q) +{ + g_hash_table_insert(table->value_to_quark, (gpointer) v, + (gpointer) (unsigned long) q); + g_hash_table_insert(table->quark_to_value, (gpointer) (unsigned long) q, + valuep); +} +#endif /* __WORDSIZE != 32 */ + +struct enum_table *enum_new(void) +{ + struct enum_table *table; + + table = g_new(struct enum_table, 1); + table->value_to_quark = g_hash_table(enum_val_hash, enum_val_equal); + table->quark_to_value = g_hash_table_new_full(g_direct_hash, + g_direct_equal, + NULL, enum_val_free); +} + +void enum_destroy(struct enum_table *table) +{ + g_hash_table_destroy(table->value_to_quark); + g_hash_table_destroy(table->quark_to_value); + g_free(table); +} diff --git a/formats/ctf/types/float.c b/formats/ctf/types/float.c new file mode 100644 index 00000000..eb0291ec --- /dev/null +++ b/formats/ctf/types/float.c @@ -0,0 +1,185 @@ +/* + * Common Trace Format + * + * Floating point read/write functions. + * + * Copyright (c) 2010 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. + * + * 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 + * + * Reference: ISO C99 standard 5.2.4 + */ + +#include +#include +#include /* C99 floating point definitions */ +#include + +/* + * This library is limited to binary representation of floating point values. + * Sign-extension of the exponents is assumed to keep the NaN, +inf, -inf + * values, but this should be double-checked (TODO). + */ + +/* + * Aliasing float/double and unsigned long is not strictly permitted by strict + * aliasing, but in practice type prunning is well supported, and this permits + * us to use per-word read/writes rather than per-byte. + */ + +#if defined(__GNUC__) || defined(__MINGW32__) || defined(_MSC_VER) +#define HAS_TYPE_PRUNING +#endif + +#if (FLT_RADIX != 2) + +#error "Unsupported floating point radix" + +#endif + +union doubleIEEE754 { + double v; +#ifdef HAS_TYPE_PRUNING + unsigned long bits[(sizeof(double) + sizeof(unsigned long) - 1) / sizeof(unsigned long)]; +#else + unsigned char bits[sizeof(double)]; +#endif +}; + +union ldoubleIEEE754 { + long double v; +#ifdef HAS_TYPE_PRUNING + unsigned long bits[(sizeof(long double) + sizeof(unsigned long) - 1) / sizeof(unsigned long)]; +#else + unsigned char bits[sizeof(long double)]; +#endif +}; + +struct pos_len { + size_t sign_start, exp_start, mantissa_start, len; +}; + +void ctf_float_copy(unsigned char *destp, const struct ctf_float *dest, + const unsigned char *src, const struct ctf_float *src) +{ + struct pos_len destpos, srcpos; + union { + unsigned long long u; + long long s; + } tmp; + + destpos.len = dest.exp_len + dest.mantissa_len; + if (dest.byte_order == LITTLE_ENDIAN) { + destpos.sign_start = destpos.len - 1; + destpos.exp_start = destpos.sign_start - dest->exp_len; + destpos.mantissa_start = 0; + } else { + destpos.sign_start = 0; + destpos.exp_start = 1; + destpos.mantissa_start = destpos.exp_start + dest->exp_len; + } + + srcpos.len = src.exp_len + src.mantissa_len; + if (src.byte_order == LITTLE_ENDIAN) { + srcpos.sign_start = srcpos.len - 1; + srcpos.exp_start = srcpos.sign_start - src->exp_len; + srcpos.mantissa_start = 0; + } else { + srcpos.sign_start = 0; + srcpos.exp_start = 1; + srcpos.mantissa_start = srcpos.exp_start + src->exp_len; + } + + /* sign */ + tmp.u = bitfield_unsigned_read(ptr, srcpos.sign_start, 1, + src->byte_order); + bitfield_unsigned_write(&u.bits, destpos.sign_start, 1, + dest->byte_order, tmp.u); + + /* mantissa (without leading 1). No sign extend. */ + tmp.u = bitfield_unsigned_read(ptr, srcpos.mantissa_start, + src->mantissa_len - 1, src->byte_order); + bitfield_unsigned_write(&u.bits, destpos.mantissa_start, + dest->mantissa_len - 1, dest->byte_order, tmp.u); + + /* exponent, with sign-extend. */ + tmp.s = bitfield_signed_read(ptr, srcpos.exp_start, src->exp_len, + src->byte_order); + bitfield_signed_write(&u.bits, destpos.exp_start, dest->exp_len, + dest->byte_order, tmp.s); +} + +double ctf_double_read(const unsigned char *ptr, const struct ctf_float *src) +{ + union doubleIEEE754 u; + struct ctf_float dest = { + .exp_len = sizeof(double) * CHAR_BIT - DBL_MANT_DIG, + .mantissa_len = DBL_MANT_DIG, + .byte_order = BYTE_ORDER, + }; + + float_copy(&u.bits, &dest, ptr, src); + return u.v; +} + +size_t ctf_double_write(unsigned char *ptr, const struct ctf_float *dest, + double v) +{ + union doubleIEEE754 u; + struct ctf_float src = { + .exp_len = sizeof(double) * CHAR_BIT - DBL_MANT_DIG, + .mantissa_len = DBL_MANT_DIG, + .byte_order = BYTE_ORDER, + }; + + if (!ptr) + goto end; + u.v = v; + float_copy(ptr, dest, &u.bits, &src); +end: + return len; +} + +long double ctf_ldouble_read(const unsigned char *ptr, + const struct ctf_float *src) +{ + union ldoubleIEEE754 u; + struct ctf_float dest = { + .exp_len = sizeof(double) * CHAR_BIT - LDBL_MANT_DIG, + .mantissa_len = LDBL_MANT_DIG, + .byte_order = BYTE_ORDER, + }; + + float_copy(&u.bits, &dest, ptr, src); + return u.v; +} + +size_t ctf_ldouble_write(unsigned char *ptr, const struct ctf_float *dest, + long double v) +{ + union ldoubleIEEE754 u; + struct ctf_float src = { + .exp_len = sizeof(double) * CHAR_BIT - LDBL_MANT_DIG, + .mantissa_len = LDBL_MANT_DIG, + .byte_order = BYTE_ORDER, + }; + + if (!ptr) + goto end; + u.v = v; + float_copy(ptr, dest, &u.bits, &src); +end: + return len; +} diff --git a/formats/ctf/types/integer.c b/formats/ctf/types/integer.c new file mode 100644 index 00000000..cd81b17a --- /dev/null +++ b/formats/ctf/types/integer.c @@ -0,0 +1,158 @@ +/* + * Common Trace Format + * + * Integers read/write functions. + * + * Copyright (c) 2010 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. + * + * 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 + */ + +#include +#include +#include +#include + +uint64_t uint_read(const uint8_t *ptr, size_t len, int byte_order) +{ + int rbo = (byte_order != BYTE_ORDER); /* reverse byte order */ + + switch (len) { + case 8: + { + uint8_t v; + + v = *(const uint8_t *)ptr; + return v; + } + case 16: + { + uint16_t v; + + v = *(const uint16_t *)ptr; + return rbo ? GUINT16_SWAP_LE_BE(v) : v; + } + case 32: + { + uint32_t v; + + v = *(const uint32_t *)ptr; + return rbo ? GUINT32_SWAP_LE_BE(v) : v; + } + case 64: + { + uint64_t v; + + v = *(const uint64_t *)ptr; + return rbo ? GUINT64_SWAP_LE_BE(v) : v; + } + default: + assert(0); + } +} + +int64_t int_read(const uint8_t *ptr, size_t len, int byte_order) +{ + int rbo = (byte_order != BYTE_ORDER); /* reverse byte order */ + + switch (len) { + case 8: + { + int8_t v; + + v = *(const int8_t *)ptr; + return v; + } + case 16: + { + int16_t v; + + v = *(const int16_t *)ptr; + return rbo ? GUINT16_SWAP_LE_BE(v) : v; + } + case 32: + { + int32_t v; + + v = *(const int32_t *)ptr; + return rbo ? GUINT32_SWAP_LE_BE(v) : v; + } + case 64: + { + int64_t v; + + v = *(const int64_t *)ptr; + return rbo ? GUINT64_SWAP_LE_BE(v) : v; + } + default: + assert(0); + } +} + +size_t uint_write(uint8_t *ptr, size_t len, int byte_order, uint64_t v) +{ + int rbo = (byte_order != BYTE_ORDER); /* reverse byte order */ + + if (!ptr) + goto end; + + switch (len) { + case 8: *(uint8_t *)ptr = (uint8_t) v; + break; + case 16: + *(uint16_t *)ptr = rbo ? GUINT16_SWAP_LE_BE((uint16_t) v) : + (uint16_t) v; + break; + case 32: + *(uint32_t *)ptr = rbo ? GUINT32_SWAP_LE_BE((uint32_t) v) : + (uint32_t) v; + break; + case 64: + *(uint64_t *)ptr = rbo ? GUINT64_SWAP_LE_BE(v) : v; + break; + default: + assert(0); + } +end: + return len; +} + +size_t int_write(uint8_t *ptr, size_t len, int byte_order, int64_t v) +{ + int rbo = (byte_order != BYTE_ORDER); /* reverse byte order */ + + if (!ptr) + goto end; + + switch (len) { + case 8: *(int8_t *)ptr = (int8_t) v; + break; + case 16: + *(int16_t *)ptr = rbo ? GUINT16_SWAP_LE_BE((int16_t) v) : + (int16_t) v; + break; + case 32: + *(int32_t *)ptr = rbo ? GUINT32_SWAP_LE_BE((int32_t) v) : + (int32_t) v; + break; + case 64: + *(int64_t *)ptr = rbo ? GUINT64_SWAP_LE_BE(v) : v; + break; + default: + assert(0); + } +end: + return len; +} diff --git a/formats/ctf/types/string.c b/formats/ctf/types/string.c new file mode 100644 index 00000000..578388d1 --- /dev/null +++ b/formats/ctf/types/string.c @@ -0,0 +1,35 @@ +/* + * Common Trace Format + * + * Strings read/write functions. + * + * Copyright (c) 2010 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. + * + * 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 + */ + +#include +#include + +size_t string_copy(char *dest, const char *src) +{ + size_t len = strlen(src) + 1; + + if (!dest) + goto end; + strcpy(dest, src); +end: + return len * 8; +} diff --git a/formats/ctf/types/struct.c b/formats/ctf/types/struct.c new file mode 100644 index 00000000..3aa8d587 --- /dev/null +++ b/formats/ctf/types/struct.c @@ -0,0 +1,26 @@ +/* + * Common Trace Format + * + * Structure write/access functions. + * + * Copyright (c) 2010 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. + * + * 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 + */ + +#include +#include + + diff --git a/lib/types/enum.c b/lib/types/enum.c deleted file mode 100644 index 507d0c35..00000000 --- a/lib/types/enum.c +++ /dev/null @@ -1,174 +0,0 @@ -/* - * Common Trace Format - * - * Enumeration mapping strings (quarks) from/to integers. - * - * Copyright (c) 2010 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. - * - * 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 - */ - -#include -#include -#include - -struct enum_table { - GHashTable *value_to_quark; /* Tuples (value, GQuark) */ - GHashTable *quark_to_value; /* Tuples (GQuark, value) */ -}; - -#if (__WORDSIZE == 32) -GQuark enum_uint_to_quark(const struct enum_table *table, uint64_t v) -{ - gconstpointer q = g_hash_table_lookup(table->value_to_quark, &v); - return (GQuark) (unsigned long) q; -} - -GQuark enum_int_to_quark(const struct enum_table *table, uint64_t v) -{ - gconstpointer q = g_hash_table_lookup(table->value_to_quark, &v); - return (GQuark) (unsigned long) q; -} - -uint64_t enum_quark_to_uint(size_t len, int byte_order, GQuark q) -{ - gconstpointer v = g_hash_table_lookup(table->quark_to_value, - (gconstpointer) q); - return *(const uint64_t *) v; -} - -int64_t enum_quark_to_int(size_t len, int byte_order, GQuark q) -{ - gconstpointer v = g_hash_table_lookup(table->quark_to_value, - (gconstpointer) q); - return *(const int64_t *) v; -} - -guint enum_val_hash(gconstpointer key) -{ - int64_t ukey = *(const int64_t *)key; - - return (guint)ukey ^ (guint)(ukey >> 32); -} - -gboolean enum_val_equal(gconstpointer a, gconstpointer b) -{ - int64_t ua = *(const int64_t *)a; - int64_t ub = *(const int64_t *)b; - - return ua == ub; -} - -void enum_val_free(void *ptr) -{ - g_free(ptr); -} - -void enum_signed_insert(struct enum_table *table, int64_t v, GQuark q) -{ - int64_t *valuep = g_new(int64_t, 1); - - g_hash_table_insert(table->value_to_quark, valuep, - (gpointer) (unsigned long) q); - g_hash_table_insert(table->quark_to_value, (gpointer) (unsigned long) q, - valuep); -} - -void enum_unsigned_insert(struct enum_table *table, uint64_t v, GQuark q) -{ - uint64_t *valuep = g_new(uint64_t, 1); - - g_hash_table_insert(table->value_to_quark, valuep, - (gpointer) (unsigned long) q); - g_hash_table_insert(table->quark_to_value, (gpointer) (unsigned long) q, - valuep); -} -#else /* __WORDSIZE != 32 */ -GQuark enum_uint_to_quark(const struct enum_table *table, uint64_t v) -{ - gconstpointer q = g_hash_table_lookup(table->value_to_quark, - (gconstpointer) v); - return (GQuark) (unsigned long) q; -} - -GQuark enum_int_to_quark(const struct enum_table *table, uint64_t v) -{ - gconstpointer q = g_hash_table_lookup(table->value_to_quark, - (gconstpointer) v); - return (GQuark) (unsigned long) q; -} - -uint64_t enum_quark_to_uint(size_t len, int byte_order, GQuark q) -{ - gconstpointer v = g_hash_table_lookup(table->quark_to_value, - (gconstpointer) (unsigned long) q); - return *(const uint64_t *) v; -} - -int64_t enum_quark_to_int(size_t len, int byte_order, GQuark q) -{ - gconstpointer v = g_hash_table_lookup(table->quark_to_value, - (gconstpointer) (unsigned long) q); - return *(const int64_t *) v; -} - -guint enum_val_hash(gconstpointer key) -{ - return g_direct_hash(key); -} - -gboolean enum_val_equal(gconstpointer a, gconstpointer b) -{ - return g_direct_equal(a, b); -} - -void enum_val_free(void *ptr) -{ -} - -void enum_signed_insert(struct enum_table *table, int64_t v, GQuark q) -{ - g_hash_table_insert(table->value_to_quark, (gpointer) v, - (gpointer) (unsigned long) q); - g_hash_table_insert(table->quark_to_value, (gpointer) (unsigned long) q, - valuep); -} - -void enum_unsigned_insert(struct enum_table *table, uint64_t v, GQuark q) -{ - g_hash_table_insert(table->value_to_quark, (gpointer) v, - (gpointer) (unsigned long) q); - g_hash_table_insert(table->quark_to_value, (gpointer) (unsigned long) q, - valuep); -} -#endif /* __WORDSIZE != 32 */ - -struct enum_table *enum_new(void) -{ - struct enum_table *table; - - table = g_new(struct enum_table, 1); - table->value_to_quark = g_hash_table(enum_val_hash, enum_val_equal); - table->quark_to_value = g_hash_table_new_full(g_direct_hash, - g_direct_equal, - NULL, enum_val_free); -} - -void enum_destroy(struct enum_table *table) -{ - g_hash_table_destroy(table->value_to_quark); - g_hash_table_destroy(table->quark_to_value); - g_free(table); -} diff --git a/lib/types/float.c b/lib/types/float.c deleted file mode 100644 index eb0291ec..00000000 --- a/lib/types/float.c +++ /dev/null @@ -1,185 +0,0 @@ -/* - * Common Trace Format - * - * Floating point read/write functions. - * - * Copyright (c) 2010 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. - * - * 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 - * - * Reference: ISO C99 standard 5.2.4 - */ - -#include -#include -#include /* C99 floating point definitions */ -#include - -/* - * This library is limited to binary representation of floating point values. - * Sign-extension of the exponents is assumed to keep the NaN, +inf, -inf - * values, but this should be double-checked (TODO). - */ - -/* - * Aliasing float/double and unsigned long is not strictly permitted by strict - * aliasing, but in practice type prunning is well supported, and this permits - * us to use per-word read/writes rather than per-byte. - */ - -#if defined(__GNUC__) || defined(__MINGW32__) || defined(_MSC_VER) -#define HAS_TYPE_PRUNING -#endif - -#if (FLT_RADIX != 2) - -#error "Unsupported floating point radix" - -#endif - -union doubleIEEE754 { - double v; -#ifdef HAS_TYPE_PRUNING - unsigned long bits[(sizeof(double) + sizeof(unsigned long) - 1) / sizeof(unsigned long)]; -#else - unsigned char bits[sizeof(double)]; -#endif -}; - -union ldoubleIEEE754 { - long double v; -#ifdef HAS_TYPE_PRUNING - unsigned long bits[(sizeof(long double) + sizeof(unsigned long) - 1) / sizeof(unsigned long)]; -#else - unsigned char bits[sizeof(long double)]; -#endif -}; - -struct pos_len { - size_t sign_start, exp_start, mantissa_start, len; -}; - -void ctf_float_copy(unsigned char *destp, const struct ctf_float *dest, - const unsigned char *src, const struct ctf_float *src) -{ - struct pos_len destpos, srcpos; - union { - unsigned long long u; - long long s; - } tmp; - - destpos.len = dest.exp_len + dest.mantissa_len; - if (dest.byte_order == LITTLE_ENDIAN) { - destpos.sign_start = destpos.len - 1; - destpos.exp_start = destpos.sign_start - dest->exp_len; - destpos.mantissa_start = 0; - } else { - destpos.sign_start = 0; - destpos.exp_start = 1; - destpos.mantissa_start = destpos.exp_start + dest->exp_len; - } - - srcpos.len = src.exp_len + src.mantissa_len; - if (src.byte_order == LITTLE_ENDIAN) { - srcpos.sign_start = srcpos.len - 1; - srcpos.exp_start = srcpos.sign_start - src->exp_len; - srcpos.mantissa_start = 0; - } else { - srcpos.sign_start = 0; - srcpos.exp_start = 1; - srcpos.mantissa_start = srcpos.exp_start + src->exp_len; - } - - /* sign */ - tmp.u = bitfield_unsigned_read(ptr, srcpos.sign_start, 1, - src->byte_order); - bitfield_unsigned_write(&u.bits, destpos.sign_start, 1, - dest->byte_order, tmp.u); - - /* mantissa (without leading 1). No sign extend. */ - tmp.u = bitfield_unsigned_read(ptr, srcpos.mantissa_start, - src->mantissa_len - 1, src->byte_order); - bitfield_unsigned_write(&u.bits, destpos.mantissa_start, - dest->mantissa_len - 1, dest->byte_order, tmp.u); - - /* exponent, with sign-extend. */ - tmp.s = bitfield_signed_read(ptr, srcpos.exp_start, src->exp_len, - src->byte_order); - bitfield_signed_write(&u.bits, destpos.exp_start, dest->exp_len, - dest->byte_order, tmp.s); -} - -double ctf_double_read(const unsigned char *ptr, const struct ctf_float *src) -{ - union doubleIEEE754 u; - struct ctf_float dest = { - .exp_len = sizeof(double) * CHAR_BIT - DBL_MANT_DIG, - .mantissa_len = DBL_MANT_DIG, - .byte_order = BYTE_ORDER, - }; - - float_copy(&u.bits, &dest, ptr, src); - return u.v; -} - -size_t ctf_double_write(unsigned char *ptr, const struct ctf_float *dest, - double v) -{ - union doubleIEEE754 u; - struct ctf_float src = { - .exp_len = sizeof(double) * CHAR_BIT - DBL_MANT_DIG, - .mantissa_len = DBL_MANT_DIG, - .byte_order = BYTE_ORDER, - }; - - if (!ptr) - goto end; - u.v = v; - float_copy(ptr, dest, &u.bits, &src); -end: - return len; -} - -long double ctf_ldouble_read(const unsigned char *ptr, - const struct ctf_float *src) -{ - union ldoubleIEEE754 u; - struct ctf_float dest = { - .exp_len = sizeof(double) * CHAR_BIT - LDBL_MANT_DIG, - .mantissa_len = LDBL_MANT_DIG, - .byte_order = BYTE_ORDER, - }; - - float_copy(&u.bits, &dest, ptr, src); - return u.v; -} - -size_t ctf_ldouble_write(unsigned char *ptr, const struct ctf_float *dest, - long double v) -{ - union ldoubleIEEE754 u; - struct ctf_float src = { - .exp_len = sizeof(double) * CHAR_BIT - LDBL_MANT_DIG, - .mantissa_len = LDBL_MANT_DIG, - .byte_order = BYTE_ORDER, - }; - - if (!ptr) - goto end; - u.v = v; - float_copy(ptr, dest, &u.bits, &src); -end: - return len; -} diff --git a/lib/types/integer.c b/lib/types/integer.c deleted file mode 100644 index cd81b17a..00000000 --- a/lib/types/integer.c +++ /dev/null @@ -1,158 +0,0 @@ -/* - * Common Trace Format - * - * Integers read/write functions. - * - * Copyright (c) 2010 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. - * - * 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 - */ - -#include -#include -#include -#include - -uint64_t uint_read(const uint8_t *ptr, size_t len, int byte_order) -{ - int rbo = (byte_order != BYTE_ORDER); /* reverse byte order */ - - switch (len) { - case 8: - { - uint8_t v; - - v = *(const uint8_t *)ptr; - return v; - } - case 16: - { - uint16_t v; - - v = *(const uint16_t *)ptr; - return rbo ? GUINT16_SWAP_LE_BE(v) : v; - } - case 32: - { - uint32_t v; - - v = *(const uint32_t *)ptr; - return rbo ? GUINT32_SWAP_LE_BE(v) : v; - } - case 64: - { - uint64_t v; - - v = *(const uint64_t *)ptr; - return rbo ? GUINT64_SWAP_LE_BE(v) : v; - } - default: - assert(0); - } -} - -int64_t int_read(const uint8_t *ptr, size_t len, int byte_order) -{ - int rbo = (byte_order != BYTE_ORDER); /* reverse byte order */ - - switch (len) { - case 8: - { - int8_t v; - - v = *(const int8_t *)ptr; - return v; - } - case 16: - { - int16_t v; - - v = *(const int16_t *)ptr; - return rbo ? GUINT16_SWAP_LE_BE(v) : v; - } - case 32: - { - int32_t v; - - v = *(const int32_t *)ptr; - return rbo ? GUINT32_SWAP_LE_BE(v) : v; - } - case 64: - { - int64_t v; - - v = *(const int64_t *)ptr; - return rbo ? GUINT64_SWAP_LE_BE(v) : v; - } - default: - assert(0); - } -} - -size_t uint_write(uint8_t *ptr, size_t len, int byte_order, uint64_t v) -{ - int rbo = (byte_order != BYTE_ORDER); /* reverse byte order */ - - if (!ptr) - goto end; - - switch (len) { - case 8: *(uint8_t *)ptr = (uint8_t) v; - break; - case 16: - *(uint16_t *)ptr = rbo ? GUINT16_SWAP_LE_BE((uint16_t) v) : - (uint16_t) v; - break; - case 32: - *(uint32_t *)ptr = rbo ? GUINT32_SWAP_LE_BE((uint32_t) v) : - (uint32_t) v; - break; - case 64: - *(uint64_t *)ptr = rbo ? GUINT64_SWAP_LE_BE(v) : v; - break; - default: - assert(0); - } -end: - return len; -} - -size_t int_write(uint8_t *ptr, size_t len, int byte_order, int64_t v) -{ - int rbo = (byte_order != BYTE_ORDER); /* reverse byte order */ - - if (!ptr) - goto end; - - switch (len) { - case 8: *(int8_t *)ptr = (int8_t) v; - break; - case 16: - *(int16_t *)ptr = rbo ? GUINT16_SWAP_LE_BE((int16_t) v) : - (int16_t) v; - break; - case 32: - *(int32_t *)ptr = rbo ? GUINT32_SWAP_LE_BE((int32_t) v) : - (int32_t) v; - break; - case 64: - *(int64_t *)ptr = rbo ? GUINT64_SWAP_LE_BE(v) : v; - break; - default: - assert(0); - } -end: - return len; -} diff --git a/lib/types/string.c b/lib/types/string.c deleted file mode 100644 index 578388d1..00000000 --- a/lib/types/string.c +++ /dev/null @@ -1,35 +0,0 @@ -/* - * Common Trace Format - * - * Strings read/write functions. - * - * Copyright (c) 2010 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. - * - * 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 - */ - -#include -#include - -size_t string_copy(char *dest, const char *src) -{ - size_t len = strlen(src) + 1; - - if (!dest) - goto end; - strcpy(dest, src); -end: - return len * 8; -} diff --git a/lib/types/struct.c b/lib/types/struct.c deleted file mode 100644 index 3aa8d587..00000000 --- a/lib/types/struct.c +++ /dev/null @@ -1,26 +0,0 @@ -/* - * Common Trace Format - * - * Structure write/access functions. - * - * Copyright (c) 2010 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. - * - * 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 - */ - -#include -#include - - diff --git a/lib/types/types.c b/lib/types/types.c deleted file mode 100644 index f6e9317c..00000000 --- a/lib/types/types.c +++ /dev/null @@ -1,80 +0,0 @@ -/* - * Common Trace Format - * - * Types registry. - * - * Copyright (c) 2010 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. - * - * 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 - */ - -#include -#include -#include - -struct type_class { - GQuark qname; - void (*read)(); - size_t (*write)(); -}; - -struct type { - struct type_class *class; - size_t alignment; /* type alignment, in bits */ - ssize_t len; /* type length, in bits. -1 for dynamic size. */ -}; - -/* - * Type class hash table contains the registered type classes. Type class - * registration is typically performed by a plugin. - * TODO: support plugin unload (unregistration of type classes). - */ -GHashTable *type_classes; - -struct type_class *ctf_lookup_type_class(GQuark qname) -{ - return g_hash_table_lookup(type_classes, - (gconstpointer) (unsigned long) qname) -} - -int ctf_register_type_class(const char *name, - void (*read)(), - void (*write)()) -{ - struct type_class tc = g_new(struct type_class, 1); - GQuark qname = g_quark_from_string(name); - - if (ctf_lookup_type_class(qname)) - return -EEXIST; - - g_hash_table_insert(type_classes, - (gconstpointer) (unsigned long) qname, - tc); - return 0; -} - -int ctf_init_types(void) -{ - type_classes = g_hash_table_new_full(g_direct_hash, g_direct_equal, - NULL, g_free); - if (!type_classes) - return -ENOMEM; - return 0; -} - -int ctf_finalize_types(void) -{ - g_hash_table_destroy(type_classes); -}