ltt/branches/poly/ltt/type.c

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