formats/ctf-text/types/integer.c

   1 /*
   2  * Common Trace Format
   3  *
   4  * Integers read/write functions.
   5  *
   6  * Copyright 2010-2011 EfficiOS Inc. and Linux Foundation
   7  *
   8  * Author: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a copy
  11  * of this software and associated documentation files (the "Software"), to deal
  12  * in the Software without restriction, including without limitation the rights
  13  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  14  * copies of the Software, and to permit persons to whom the Software is
  15  * furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included in
  18  * all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  23  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  25  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  26  * SOFTWARE.
  27  */
  28
  29 #include <babeltrace/ctf-text/types.h>
  30 #include <stdio.h>
  31 #include <inttypes.h>
  32 #include <stdint.h>
  33 #include <babeltrace/bitfield.h>
  34 #include <babeltrace/trace-debug-info.h>
  35
  36 int ctf_text_integer_write(struct bt_stream_pos *ppos, struct bt_definition *definition)
  37 {
  38         struct definition_integer *integer_definition =
  39                 container_of(definition, struct definition_integer, p);
  40         const struct declaration_integer *integer_declaration =
  41                 integer_definition->declaration;
  42         struct ctf_text_stream_pos *pos = ctf_text_pos(ppos);
  43
  44         if (!print_field(definition))
  45                 return 0;
  46
  47         if (pos->dummy)
  48                 return 0;
  49
  50         if (pos->field_nr++ != 0)
  51                 fprintf(pos->fp, ",");
  52         fprintf(pos->fp, " ");
  53         if (pos->print_names)
  54                 fprintf(pos->fp, "%s = ",
  55                         rem_(g_quark_to_string(definition->name)));
  56
  57         if (pos->string
  58             && (integer_declaration->encoding == CTF_STRING_ASCII
  59               || integer_declaration->encoding == CTF_STRING_UTF8)) {
  60
  61                 if (!integer_declaration->signedness) {
  62                         g_string_append_c(pos->string,
  63                                 (int) integer_definition->value._unsigned);
  64                 } else {
  65                         g_string_append_c(pos->string,
  66                                 (int) integer_definition->value._signed);
  67                 }
  68                 return 0;
  69         }
  70
  71         switch (integer_declaration->base) {
  72         case 0: /* default */
  73         case 10:
  74                 if (!integer_declaration->signedness) {
  75                         fprintf(pos->fp, "%" PRIu64,
  76                                 integer_definition->value._unsigned);
  77                 } else {
  78                         fprintf(pos->fp, "%" PRId64,
  79                                 integer_definition->value._signed);
  80                 }
  81                 break;
  82         case 2:
  83         {
  84                 int bitnr;
  85                 uint64_t v;
  86
  87                 if (!integer_declaration->signedness)
  88                         v = integer_definition->value._unsigned;
  89                 else
  90                         v = (uint64_t) integer_definition->value._signed;
  91
  92                 fprintf(pos->fp, "0b");
  93                 v = _bt_piecewise_lshift(v, 64 - integer_declaration->len);
  94                 for (bitnr = 0; bitnr < integer_declaration->len; bitnr++) {
  95                         fprintf(pos->fp, "%u", (v & (1ULL << 63)) ? 1 : 0);
  96                         v = _bt_piecewise_lshift(v, 1);
  97                 }
  98                 break;
  99         }
 100         case 8:
 101         {
 102                 uint64_t v;
 103
 104                 if (!integer_declaration->signedness) {
 105                         v = integer_definition->value._unsigned;
 106                 } else {
 107                         v = (uint64_t) integer_definition->value._signed;
 108                         if (integer_declaration->len < 64) {
 109                                 /* Round length to the nearest 3-bit */
 110                                 uint8_t rounded_len =
 111                                         integer_declaration->len +
 112                                         ((integer_declaration->len + 2) % 3);
 113
 114                                 v &= ((uint64_t) 1 << rounded_len) - 1;
 115                         }
 116                 }
 117
 118                 fprintf(pos->fp, "0%" PRIo64, v);
 119                 break;
 120         }
 121         case 16:
 122         {
 123                 uint64_t v;
 124
 125                 if (!integer_declaration->signedness) {
 126                         v = integer_definition->value._unsigned;
 127                 } else {
 128                         v = (uint64_t) integer_definition->value._signed;
 129                         if (integer_declaration->len < 64) {
 130                                 /* Round length to the nearest nibble */
 131                                 uint8_t rounded_len =
 132                                         ((integer_declaration->len + 3) & ~0x3);
 133
 134                                 v &= ((uint64_t) 1 << rounded_len) - 1;
 135                         }
 136                 }
 137
 138                 fprintf(pos->fp, "0x%" PRIX64, v);
 139                 break;
 140         }
 141         default:
 142                 return -EINVAL;
 143         }
 144
 145         ctf_text_integer_write_debug_info(ppos, definition);
 146
 147         return 0;
 148 }