ltt/branches/poly/ltt/type.c

   1 #include <stdio.h>
   2
   3 #include <ltt/LTTTypes.h>
   4 #include "parser.h"
   5 #include <ltt/type.h>
   6
   7 static unsigned intSizes[] = {
   8   sizeof(int8_t), sizeof(int16_t), sizeof(int32_t), sizeof(int64_t),
   9   sizeof(short) };
  10
  11 static unsigned floatSizes[] = {
  12   0, 0, sizeof(float), sizeof(double), 0, sizeof(float), sizeof(double) };
  13
  14
  15 /*****************************************************************************
  16  *Function name
  17  *    ltt_eventtype_name : get the name of the event type
  18  *Input params
  19  *    et                 : an  event type
  20  *Return value
  21  *    char *             : the name of the event type
  22  ****************************************************************************/
  23
  24 char *ltt_eventtype_name(LttEventType *et)
  25 {
  26   return et->name;
  27 }
  28
  29 /*****************************************************************************
  30  *Function name
  31  *    ltt_eventtype_description : get the description of the event type
  32  *Input params
  33  *    et                 : an  event type
  34  *Return value
  35  *    char *             : the description of the event type
  36  ****************************************************************************/
  37
  38 char *ltt_eventtype_description(LttEventType *et)
  39 {
  40   return et->description;
  41 }
  42
  43 /*****************************************************************************
  44  *Function name
  45  *    ltt_eventtype_facility : get the facility which contains the event type
  46  *Input params
  47  *    et                     : an  event type
  48  *Return value
  49  *    LttFacility *          : the facility
  50  ****************************************************************************/
  51
  52 LttFacility *ltt_eventtype_facility(LttEventType *et)
  53 {
  54   return et->facility;
  55 }
  56
  57 /*****************************************************************************
  58  *Function name
  59  *    ltt_eventtype_relative_id : get the relative id of the event type
  60  *Input params
  61  *    et                        : an  event type
  62  *Return value
  63  *    unsigned *                : the relative id
  64  ****************************************************************************/
  65
  66 unsigned *ltt_eventtype_relative_id(LttEventType *et)
  67 {
  68   return (unsigned*)&et->index;
  69 }
  70
  71 /*****************************************************************************
  72  *Function name
  73  *    ltt_eventtype_id : get the id of the event type
  74  *Input params
  75  *    et               : an  event type
  76  *Return value
  77  *    unsigned *       : the id
  78  ****************************************************************************/
  79
  80 unsigned *ltt_eventtype_id(LttEventType *et)
  81 {
  82   unsigned *id = g_new(unsigned,1);
  83   *id = et->facility->base_id + et->index;
  84   return (unsigned*)id;
  85 }
  86
  87 /*****************************************************************************
  88  *Function name
  89  *    ltt_eventtype_type : get the type of the event type
  90  *Input params
  91  *    et                 : an  event type
  92  *Return value
  93  *    LttType *         : the type of the event type
  94  ****************************************************************************/
  95
  96 LttType *ltt_eventtype_type(LttEventType *et)
  97 {
  98   return et->root_field->field_type;
  99 }
 100
 101 /*****************************************************************************
 102  *Function name
 103  *    ltt_eventtype_field : get the root filed of the event type
 104  *Input params
 105  *    et                  : an  event type
 106  *Return value
 107  *    LttField *          : the root filed of the event type
 108  ****************************************************************************/
 109
 110 LttField *ltt_eventtype_field(LttEventType *et)
 111 {
 112   return et->root_field;
 113 }
 114
 115 /*****************************************************************************
 116  *Function name
 117  *    ltt_type_name  : get the name of the type
 118  *Input params
 119  *    t              : a type
 120  *Return value
 121  *    char *         : the name of the type
 122  ****************************************************************************/
 123
 124 char *ltt_type_name(LttType *t)
 125 {
 126   return t->element_name;
 127 }
 128
 129 /*****************************************************************************
 130  *Function name
 131  *    ltt_type_class : get the type class of the type
 132  *Input params
 133  *    t              : a type
 134  *Return value
 135  *    LttTypeEnum  : the type class of the type
 136  ****************************************************************************/
 137
 138 LttTypeEnum ltt_type_class(LttType *t)
 139 {
 140   return t->type_class;
 141 }
 142
 143 /*****************************************************************************
 144  *Function name
 145  *    ltt_type_size : obtain the type size. The size is the number of bytes
 146  *                    for primitive types (INT, UINT, FLOAT, ENUM), or the
 147  *                    size for the unsigned integer length count for sequences
 148  *Input params
 149  *    tf            : trace file
 150  *    t             : a type
 151  *Return value
 152  *    unsigned      : the type size
 153  ****************************************************************************/
 154
 155 unsigned ltt_type_size(LttTrace * trace, LttType *t)
 156 {
 157   if(t->type_class==LTT_STRUCT || t->type_class==LTT_ARRAY ||
 158      t->type_class==LTT_STRING) return 0;
 159
 160   if(t->type_class == LTT_FLOAT){
 161     return floatSizes[t->size];
 162   }else{
 163     if(t->size < sizeof(intSizes)/sizeof(unsigned))
 164       return intSizes[t->size];
 165     else{
 166       LttArchSize size = trace->system_description->size;
 167       if(size == LTT_LP32){
 168         if(t->size == 5)return sizeof(int16_t);
 169         else return sizeof(int32_t);
 170       }
 171       else if(size == LTT_ILP32 || size == LTT_LP64){
 172         if(t->size == 5)return sizeof(int32_t);
 173         else{
 174           if(size == LTT_ILP32) return sizeof(int32_t);
 175           else return sizeof(int64_t);
 176         }
 177       }
 178       else if(size == LTT_ILP64)return sizeof(int64_t);
 179     }
 180   }
 181 }
 182
 183 /*****************************************************************************
 184  *Function name
 185  *    ltt_type_element_type : obtain the type of nested elements for arrays
 186  *                            and sequences
 187  *Input params
 188  *    t                     : a type
 189  *Return value
 190  *    LttType              : the type of nested element of array or sequence
 191  ****************************************************************************/
 192
 193 LttType *ltt_type_element_type(LttType *t)
 194 {
 195   if(t->type_class != LTT_ARRAY && t->type_class != LTT_SEQUENCE)
 196     return NULL;
 197   return t->element_type[0];
 198 }
 199
 200 /*****************************************************************************
 201  *Function name
 202  *    ltt_type_element_number : obtain the number of elements for arrays
 203  *Input params
 204  *    t                       : a type
 205  *Return value
 206  *    unsigned                : the number of elements for arrays
 207  ****************************************************************************/
 208
 209 unsigned ltt_type_element_number(LttType *t)
 210 {
 211   if(t->type_class != LTT_ARRAY)
 212     return 0;
 213   return t->element_number;
 214 }
 215
 216 /*****************************************************************************
 217  *Function name
 218  *    ltt_type_member_number : obtain the number of data members for structure
 219  *Input params
 220  *    t                      : a type
 221  *Return value
 222  *    unsigned               : the number of members for structure
 223  ****************************************************************************/
 224
 225 unsigned ltt_type_member_number(LttType *t)
 226 {
 227   if(t->type_class != LTT_STRUCT && t->type_class != LTT_UNION)
 228     return 0;
 229   return t->element_number;
 230 }
 231
 232 /*****************************************************************************
 233  *Function name
 234  *    ltt_type_member_type : obtain the type of a data members in a structure
 235  *Input params
 236  *    t                    : a type
 237  *    i                    : index of the member
 238  *Return value
 239  *    LttType *           : the type of structure member
 240  ****************************************************************************/
 241
 242 LttType *ltt_type_member_type(LttType *t, unsigned i, char ** name)
 243 {
 244   if(t->type_class != LTT_STRUCT){*name == NULL; return NULL;}
 245   if(i >= t->element_number || i < 0 ){*name = NULL; return NULL;}
 246   *name = t->element_name;
 247   return t->element_type[i];
 248 }
 249
 250 /*****************************************************************************
 251  *Function name
 252  *    ltt_enum_string_get : for enumerations, obtain the symbolic string
 253  *                          associated with a value (0 to n - 1 for an
 254  *                          enumeration of n elements)
 255  *Input params
 256  *    t                   : a type
 257  *    i                   : index of the member
 258  *Return value
 259  *    char *              : symbolic string associated with a value
 260  ****************************************************************************/
 261
 262 char *ltt_enum_string_get(LttType *t, unsigned i)
 263 {
 264   if(t->type_class != LTT_ENUM) return NULL;
 265   if(i >= t->element_number || i < 0 ) return NULL;
 266   return t->enum_strings[i];
 267 }
 268
 269 /*****************************************************************************
 270  *Function name
 271  *    ltt_field_element : obtain the field of nested elements for arrays and
 272  *                        sequence
 273  *Input params
 274  *    f                 : a field
 275  *Return value
 276  *    LttField *       : the field of the nested element
 277  ****************************************************************************/
 278
 279 LttField *ltt_field_element(LttField *f)
 280 {
 281   if(f->field_type->type_class != LTT_ARRAY &&
 282      f->field_type->type_class != LTT_SEQUENCE)
 283     return NULL;
 284
 285   return f->child[0];
 286 }
 287
 288 /*****************************************************************************
 289  *Function name
 290  *    ltt_field_member  : obtain the filed of data members for structure
 291  *Input params
 292  *    f                 : a field
 293  *    i                 : index of member field
 294  *Return value
 295  *    LttField *       : the field of the nested element
 296  ****************************************************************************/
 297
 298 LttField *ltt_field_member(LttField *f, unsigned i)
 299 {
 300   if(f->field_type->type_class != LTT_STRUCT) return NULL;
 301   if(i < 0 || i >= f->field_type->element_number) return NULL;
 302   return f->child[i];
 303 }
 304
 305 /*****************************************************************************
 306  *Function name
 307  *    ltt_field_type  : obtain the type of the field
 308  *Input params
 309  *    f               : a field
 310  *Return value
 311  *    ltt_tyoe *      : the type of field
 312  ****************************************************************************/
 313
 314 LttType *ltt_field_type(LttField *f)
 315 {
 316   return f->field_type;
 317 }
 318