ltt/branches/poly/ltt/event.c

   1 /* This file is part of the Linux Trace Toolkit viewer
   2  * Copyright (C) 2003-2004 Xiangxiu Yang
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License Version 2 as
   6  * published by the Free Software Foundation;
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write to the Free Software
  15  * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  16  * MA 02111-1307, USA.
  17  */
  18
  19 #include <stdio.h>
  20 #include <string.h>
  21 #include <stdlib.h>
  22
  23 #include <asm/types.h>
  24 #include <linux/byteorder/swab.h>
  25
  26 #include "parser.h"
  27 #include <ltt/ltt.h>
  28 #include "ltt-private.h"
  29 #include <ltt/event.h>
  30 #include <ltt/trace.h>
  31
  32
  33 LttEvent *ltt_event_new()
  34 {
  35   return g_new(LttEvent, 1);
  36 }
  37
  38 void ltt_event_destroy(LttEvent *event)
  39 {
  40   g_free(event);
  41 }
  42
  43
  44 /*****************************************************************************
  45  *Function name
  46  *    ltt_event_refresh_fields   : refresh fields of an event
  47  *Input params
  48  *    offsetRoot      : offset from the root
  49  *    offsetParent    : offset from the parent
  50  *    fld             : field
  51  *    evD             : event data
  52  *Return value
  53  *    int             : size of the field
  54  ****************************************************************************/
  55
  56 int ltt_event_refresh_fields(int offsetRoot,int offsetParent,
  57                              LttField * fld, void *evD)
  58 {
  59   int size, size1, element_number, i, offset1, offset2;
  60   LttType * type = fld->field_type;
  61
  62   switch(type->type_class) {
  63     case LTT_ARRAY:
  64       element_number = (int) type->element_number;
  65       if(fld->field_fixed == 0){// has string or sequence
  66         size = 0;
  67         for(i=0;i<element_number;i++){
  68           size += ltt_event_refresh_fields(offsetRoot+size,size,
  69              fld->child[0], evD+size);
  70         }
  71       }else size = fld->field_size;
  72       break;
  73
  74     case LTT_SEQUENCE:
  75       size1 = fld->sequ_number_size;
  76       element_number = getIntNumber(size1,evD);
  77       type->element_number = element_number;
  78       if(fld->element_size > 0){
  79         size = element_number * fld->element_size;
  80       }else{//sequence has string or sequence
  81         size = 0;
  82         for(i=0;i<element_number;i++){
  83           size += ltt_event_refresh_fields(offsetRoot+size+size1,size+size1,
  84                    fld->child[0], evD+size+size1);
  85         }
  86         size += size1;
  87       }
  88       break;
  89
  90     case LTT_STRING:
  91       size = strlen((char*)evD) + 1; //include end : '\0'
  92       break;
  93
  94     case LTT_STRUCT:
  95       element_number = (int) type->element_number;
  96       if(fld->field_fixed == 0){
  97         offset1 = offsetRoot;
  98         offset2 = 0;
  99         for(i=0;i<element_number;i++){
 100           size=ltt_event_refresh_fields(offset1,offset2,
 101                                         fld->child[i],evD+offset2);
 102           offset1 += size;
 103           offset2 += size;
 104         }
 105         size = offset2;
 106       }else size = fld->field_size;
 107       break;
 108
 109     case LTT_UNION:
 110       size = fld->field_size;
 111       break;
 112
 113     default:
 114       size = fld->field_size;
 115   }
 116
 117 #if 0
 118   if(type->type_class != LTT_STRUCT && type->type_class != LTT_ARRAY &&
 119      type->type_class != LTT_SEQUENCE && type->type_class != LTT_STRING){
 120     size = fld->field_size;
 121   }else if(type->type_class == LTT_ARRAY){
 122     element_number = (int) type->element_number;
 123     if(fld->field_fixed == 0){// has string or sequence
 124       size = 0;
 125       for(i=0;i<element_number;i++){
 126               size += ltt_event_refresh_fields(offsetRoot+size,size,
 127                                          fld->child[0], evD+size);
 128       }
 129     }else size = fld->field_size;
 130   }else if(type->type_class == LTT_SEQUENCE){
 131     size1 = fld->sequ_number_size;
 132     element_number = getIntNumber(size1,evD);
 133     type->element_number = element_number;
 134     if(fld->element_size > 0){
 135       size = element_number * fld->element_size;
 136     }else{//sequence has string or sequence
 137       size = 0;
 138       for(i=0;i<element_number;i++){
 139               size += ltt_event_refresh_fields(offsetRoot+size+size1,size+size1,
 140                                          fld->child[0], evD+size+size1);
 141       }
 142       size += size1;
 143     }
 144   }else if(type->type_class == LTT_STRING){
 145     size = strlen((char*)evD) + 1; //include end : '\0'
 146   }else if(type->type_class == LTT_STRUCT){
 147     element_number = (int) type->element_number;
 148     if(fld->field_fixed == 0){
 149       offset1 = offsetRoot;
 150       offset2 = 0;
 151       for(i=0;i<element_number;i++){
 152               size=ltt_event_refresh_fields(offset1,offset2,
 153                                       fld->child[i],evD+offset2);
 154         offset1 += size;
 155         offset2 += size;
 156       }
 157       size = offset2;
 158     }else size = fld->field_size;
 159   }
 160 #endif //0
 161   fld->offset_root     = offsetRoot;
 162   fld->offset_parent   = offsetParent;
 163   fld->fixed_root      = (offsetRoot==-1)   ? 0 : 1;
 164   fld->fixed_parent    = (offsetParent==-1) ? 0 : 1;
 165   fld->field_size      = size;
 166
 167   return size;
 168 }
 169
 170 /*****************************************************************************
 171  *Function name
 172  *    ltt_event_eventtype_id: get event type id
 173  *                            (base id + position of the event)
 174  *Input params
 175  *    e                     : an instance of an event type
 176  *Return value
 177  *    unsigned              : event type id
 178  ****************************************************************************/
 179
 180 unsigned ltt_event_eventtype_id(LttEvent *e)
 181 {
 182   return (unsigned) e->event_id;
 183 }
 184
 185 /*****************************************************************************
 186  *Function name
 187  *    ltt_event_facility : get the facility of the event
 188  *Input params
 189  *    e                  : an instance of an event type
 190  *Return value
 191  *    LttFacility *     : the facility of the event
 192  ****************************************************************************/
 193
 194 LttFacility *ltt_event_facility(LttEvent *e)
 195 {
 196   LttTrace * trace = e->tracefile->trace;
 197   unsigned id = e->event_id;
 198   return ltt_trace_facility_by_id(trace,id);
 199 }
 200
 201 /*****************************************************************************
 202  *Function name
 203  *    ltt_event_eventtype : get the event type of the event
 204  *Input params
 205  *    e                   : an instance of an event type
 206  *Return value
 207  *    LttEventType *     : the event type of the event
 208  ****************************************************************************/
 209
 210 LttEventType *ltt_event_eventtype(LttEvent *e)
 211 {
 212   LttFacility* facility = ltt_event_facility(e);
 213   if(!facility) return NULL;
 214   return facility->events[e->event_id - facility->base_id];
 215 }
 216
 217 /*****************************************************************************
 218  *Function name
 219  *    ltt_event_field : get the root field of the event
 220  *Input params
 221  *    e               : an instance of an event type
 222  *Return value
 223  *    LttField *      : the root field of the event
 224  ****************************************************************************/
 225
 226 LttField *ltt_event_field(LttEvent *e)
 227 {
 228   LttField * field;
 229   LttEventType * event_type = ltt_event_eventtype(e);
 230   if(!event_type) return NULL;
 231   field = event_type->root_field;
 232   if(!field) return NULL;
 233
 234   //check if the field need refresh
 235   if(e->which_block != event_type->latest_block ||
 236      e->which_event != event_type->latest_event){
 237
 238     event_type->latest_block = e->which_block;
 239     event_type->latest_event = e->which_event;
 240
 241     if(field->field_fixed == 1)return field;
 242
 243     //refresh the field
 244     ltt_event_refresh_fields(0, 0, field, e->data);
 245   }
 246   return field;
 247 }
 248
 249 /*****************************************************************************
 250  *Function name
 251  *    ltt_event_time : get the time of the event
 252  *Input params
 253  *    e              : an instance of an event type
 254  *Return value
 255  *    LttTime       : the time of the event
 256  ****************************************************************************/
 257
 258 LttTime ltt_event_time(LttEvent *e)
 259 {
 260   return e->event_time;
 261 }
 262
 263 /*****************************************************************************
 264  *Function name
 265  *    ltt_event_time : get the cycle count of the event
 266  *Input params
 267  *    e              : an instance of an event type
 268  *Return value
 269  *    LttCycleCount  : the cycle count of the event
 270  ****************************************************************************/
 271
 272 LttCycleCount ltt_event_cycle_count(LttEvent *e)
 273 {
 274   return e->event_cycle_count;
 275 }
 276
 277 /*****************************************************************************
 278  *Function name
 279  *    ltt_event_position : get the event's position
 280  *Input params
 281  *    e                  : an instance of an event type
 282  *    ep                 : a pointer to event's position structure
 283  ****************************************************************************/
 284
 285 void ltt_event_position(LttEvent *e, LttEventPosition *ep)
 286 {
 287   ep->block_num         = e->which_block;
 288   ep->event_num         = e->which_event;
 289   ep->event_time        = e->event_time;
 290   ep->event_cycle_count = e->event_cycle_count;
 291   ep->heart_beat_number = e->tracefile->cur_heart_beat_number;
 292   ep->old_position      = TRUE;
 293   ep->event_offset      = e->data - e->tracefile->buffer - EVENT_HEADER_SIZE ;
 294   ep->tf                = e->tracefile;
 295
 296   /* This is a workaround for fast position seek */
 297   ep->last_event_pos = e->last_event_pos;
 298   ep->prev_block_end_time = e->prev_block_end_time;
 299   ep->prev_event_time = e->prev_event_time;
 300   ep->pre_cycle_count = e->pre_cycle_count;
 301   ep->count = e->count;
 302   /* end of workaround */
 303 }
 304
 305 LttEventPosition * ltt_event_position_new()
 306 {
 307   return g_new(LttEventPosition, 1);
 308 }
 309
 310 /*****************************************************************************
 311  *Function name
 312  *    ltt_event_position_get : get the block number and index of the event
 313  *Input params
 314  *    ep                     : a pointer to event's position structure
 315  *    block_number           : the block number of the event
 316  *    index_in_block         : the index of the event within the block
 317  ****************************************************************************/
 318
 319 void ltt_event_position_get(LttEventPosition *ep,
 320     unsigned *block_number, unsigned *index_in_block, LttTracefile ** tf)
 321 {
 322   *block_number   = ep->block_num;
 323   *index_in_block = ep->event_num;
 324   *tf             = ep->tf;
 325 }
 326
 327 /*****************************************************************************
 328  *Function name
 329  *    ltt_event_position_set : set the block number and index of the event
 330  *    It does put the old_position gboolean to FALSE, as it is impossible
 331  *    to know the quick position to seek in the tracefile.
 332  *Input params
 333  *    ep                     : a pointer to event's position structure
 334  *    block_number           : the block number of the event
 335  *    index_in_block         : the index of the event within the block
 336  ****************************************************************************/
 337
 338 void ltt_event_position_set(LttEventPosition *ep,
 339     unsigned block_number, unsigned index_in_block)
 340 {
 341   if(ep->block_num != block_number || ep->event_num != index_in_block)
 342     ep->old_position = FALSE;
 343
 344   ep->block_num = block_number;
 345   ep->event_num = index_in_block;
 346
 347 }
 348
 349 /*****************************************************************************
 350  * Function name
 351  *    ltt_event_position_compare : compare two positions
 352  *    A NULL value is infinite.
 353  * Input params
 354  *    ep1                    : a pointer to event's position structure
 355  *    ep2                    : a pointer to event's position structure
 356  * Return
 357  *    -1 is ep1 < ep2
 358  *    1 if ep1 > ep2
 359  *    0 if ep1 == ep2
 360  ****************************************************************************/
 361
 362
 363 gint ltt_event_position_compare(const LttEventPosition *ep1,
 364                                 const LttEventPosition *ep2)
 365 {
 366   if(ep1->tf != ep2->tf)
 367     g_error("ltt_event_position_compare on different tracefiles makes no sense");
 368   if(ep1 == NULL && ep2 == NULL)
 369       return 0;
 370   if(ep1 != NULL && ep2 == NULL)
 371       return -1;
 372   if(ep1 == NULL && ep2 != NULL)
 373       return 1;
 374
 375   if(ep1->block_num < ep2->block_num)
 376     return -1;
 377   if(ep1->block_num > ep2->block_num)
 378     return 1;
 379   if(ep1->event_num < ep2->event_num)
 380     return -1;
 381   if(ep1->event_num > ep2->event_num)
 382     return 1;
 383   return 0;
 384 }
 385
 386 /*****************************************************************************
 387  * Function name
 388  *    ltt_event_event_position_compare : compare two positions, one in event,
 389  *    other in position opaque structure.
 390  * Input params
 391  *    event                  : a pointer to event structure
 392  *    ep                     : a pointer to event's position structure
 393  * Return
 394  *    -1 is event < ep
 395  *    1 if event > ep
 396  *    0 if event == ep
 397  ****************************************************************************/
 398
 399 gint ltt_event_event_position_compare(const LttEvent *event,
 400                                       const LttEventPosition *ep)
 401 {
 402   if(event == NULL && ep == NULL)
 403       return 0;
 404   if(event != NULL && ep == NULL)
 405       return -1;
 406   if(event == NULL && ep != NULL)
 407       return 1;
 408
 409   g_assert(event->tracefile == ep->tf);
 410
 411   if(event->which_block < ep->block_num)
 412     return -1;
 413   if(event->which_block > ep->block_num)
 414     return 1;
 415   if(event->which_event < ep->event_num)
 416     return -1;
 417   if(event->which_event > ep->event_num)
 418     return 1;
 419   return 0;
 420 }
 421
 422 /*****************************************************************************
 423  * Function name
 424  *    ltt_event_position_copy : copy position
 425  * Input params
 426  *    src                    : a pointer to event's position structure source
 427  *    dest                   : a pointer to event's position structure dest
 428  * Return
 429  *    void
 430  ****************************************************************************/
 431 void ltt_event_position_copy(LttEventPosition *dest,
 432                              const LttEventPosition *src)
 433 {
 434   if(src == NULL)
 435     dest = NULL;
 436   else
 437     *dest = *src;
 438 }
 439
 440
 441 /*****************************************************************************
 442  *Function name
 443  *    ltt_event_cpu_i: get the cpu id where the event happens
 444  *Input params
 445  *    e              : an instance of an event type
 446  *Return value
 447  *    unsigned       : the cpu id
 448  ****************************************************************************/
 449
 450 unsigned ltt_event_cpu_id(LttEvent *e)
 451 {
 452   char * c1, * c2, * c3;
 453   c1 = strrchr(e->tracefile->name,'\\');
 454   c2 = strrchr(e->tracefile->name,'/');
 455   if(c1 == NULL && c2 == NULL){
 456     return (unsigned)atoi(e->tracefile->name);
 457   }else if(c1 == NULL){
 458     c2++;
 459     return (unsigned)atoi(c2);
 460   }else if(c2 == NULL){
 461     c1++;
 462     return (unsigned)atoi(c1);
 463   }else{
 464     c3 = (c1 > c2) ? c1 : c2;
 465     c3++;
 466     return (unsigned)atoi(c3);
 467   }
 468 }
 469
 470 /*****************************************************************************
 471  *Function name
 472  *    ltt_event_data : get the raw data for the event
 473  *Input params
 474  *    e              : an instance of an event type
 475  *Return value
 476  *    void *         : pointer to the raw data for the event
 477  ****************************************************************************/
 478
 479 void *ltt_event_data(LttEvent *e)
 480 {
 481   return e->data;
 482 }
 483
 484 /*****************************************************************************
 485  *Function name
 486  *    ltt_event_field_element_number
 487  *                   : The number of elements in a sequence field is specific
 488  *                     to each event. This function returns the number of
 489  *                     elements for an array or sequence field in an event.
 490  *Input params
 491  *    e              : an instance of an event type
 492  *    f              : a field of the instance
 493  *Return value
 494  *    unsigned       : the number of elements for an array/sequence field
 495  ****************************************************************************/
 496
 497 unsigned ltt_event_field_element_number(LttEvent *e, LttField *f)
 498 {
 499   if(f->field_type->type_class != LTT_ARRAY &&
 500      f->field_type->type_class != LTT_SEQUENCE)
 501     return 0;
 502
 503   if(f->field_type->type_class == LTT_ARRAY)
 504     return f->field_type->element_number;
 505   return (unsigned)  getIntNumber(f->sequ_number_size, e + f->offset_root);
 506 }
 507
 508 /*****************************************************************************
 509  *Function name
 510  *    ltt_event_field_element_select
 511  *                   : Set the currently selected element for a sequence or
 512  *                     array field
 513  *Input params
 514  *    e              : an instance of an event type
 515  *    f              : a field of the instance
 516  *    i              : the ith element
 517  ****************************************************************************/
 518
 519 void ltt_event_field_element_select(LttEvent *e, LttField *f, unsigned i)
 520 {
 521   unsigned element_number;
 522   LttField *fld;
 523   unsigned int k;
 524   int size;
 525   void *evD;
 526
 527   if(f->field_type->type_class != LTT_ARRAY &&
 528      f->field_type->type_class != LTT_SEQUENCE)
 529     return ;
 530
 531   element_number  = ltt_event_field_element_number(e,f);
 532   /* Sanity check for i : 1..n only, and must be lower or equal element_number
 533    */
 534   if(element_number < i || i == 0) return;
 535
 536   fld = f->child[0];
 537
 538   evD = e->data + f->offset_root;
 539   size = 0;
 540   for(k=0;k<i;k++){
 541     size += ltt_event_refresh_fields(f->offset_root+size,size, fld, evD+size);
 542   }
 543   f->current_element = i - 1;
 544 }
 545
 546 /*****************************************************************************
 547  * These functions extract data from an event after architecture specific
 548  * conversions
 549  ****************************************************************************/
 550
 551 unsigned ltt_event_get_unsigned(LttEvent *e, LttField *f)
 552 {
 553   int revFlag = e->tracefile->trace->my_arch_endian ==
 554                 e->tracefile->trace->system_description->endian ? 0:1;
 555   LttTypeEnum t = f->field_type->type_class;
 556
 557   g_assert(t == LTT_UINT || t == LTT_ENUM);
 558
 559   if(f->field_size == 1){
 560     guint8 x = *(guint8 *)(e->data + f->offset_root);
 561     return (unsigned int) x;
 562   }else if(f->field_size == 2){
 563     guint16 x = *(guint16 *)(e->data + f->offset_root);
 564     if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
 565       return (unsigned int) (revFlag ? GUINT16_FROM_BE(x): x);
 566     else
 567       return (unsigned int) (revFlag ? GUINT16_FROM_LE(x): x);
 568   }else if(f->field_size == 4){
 569     guint32 x = *(guint32 *)(e->data + f->offset_root);
 570     if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
 571       return (unsigned int) (revFlag ? GUINT32_FROM_BE(x): x);
 572     else
 573       return (unsigned int) (revFlag ? GUINT32_FROM_LE(x): x);
 574   }else if(f->field_size == 8){
 575     guint64 x = *(guint64 *)(e->data + f->offset_root);
 576     if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
 577       return (unsigned int) (revFlag ? GUINT64_FROM_BE(x): x);
 578     else
 579       return (unsigned int) (revFlag ? GUINT64_FROM_LE(x): x);
 580   }
 581   g_critical("ltt_event_get_unsigned : field size %i unknown", f->field_size);
 582   return 0;
 583 }
 584
 585 int ltt_event_get_int(LttEvent *e, LttField *f)
 586 {
 587   int revFlag = e->tracefile->trace->my_arch_endian ==
 588                 e->tracefile->trace->system_description->endian ? 0:1;
 589
 590   g_assert(f->field_type->type_class == LTT_INT);
 591
 592   if(f->field_size == 1){
 593     gint8 x = *(gint8 *)(e->data + f->offset_root);
 594     return (int) x;
 595   }else if(f->field_size == 2){
 596     gint16 x = *(gint16 *)(e->data + f->offset_root);
 597     if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
 598       return (int) (revFlag ? GINT16_FROM_BE(x): x);
 599     else
 600       return (int) (revFlag ? GINT16_FROM_LE(x): x);
 601   }else if(f->field_size == 4){
 602     gint32 x = *(gint32 *)(e->data + f->offset_root);
 603     if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
 604       return (int) (revFlag ? GINT32_FROM_BE(x): x);
 605     else
 606       return (int) (revFlag ? GINT32_FROM_LE(x): x);
 607   }else if(f->field_size == 8){
 608     gint64 x = *(gint64 *)(e->data + f->offset_root);
 609     if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
 610       return (int) (revFlag ? GINT64_FROM_BE(x): x);
 611     else
 612       return (int) (revFlag ? GINT64_FROM_LE(x): x);
 613   }
 614   g_critical("ltt_event_get_int : field size %i unknown", f->field_size);
 615   return 0;
 616 }
 617
 618 unsigned long ltt_event_get_long_unsigned(LttEvent *e, LttField *f)
 619 {
 620   int revFlag = e->tracefile->trace->my_arch_endian ==
 621                 e->tracefile->trace->system_description->endian ? 0:1;
 622   LttTypeEnum t = f->field_type->type_class;
 623
 624   g_assert(t == LTT_UINT || t == LTT_ENUM);
 625
 626   if(f->field_size == 1){
 627     guint8 x = *(guint8 *)(e->data + f->offset_root);
 628     return (unsigned long) x;
 629   }else if(f->field_size == 2){
 630     guint16 x = *(guint16 *)(e->data + f->offset_root);
 631     if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
 632       return (unsigned long) (revFlag ? GUINT16_FROM_BE(x): x);
 633     else
 634       return (unsigned long) (revFlag ? GUINT16_FROM_LE(x): x);
 635   }else if(f->field_size == 4){
 636     guint32 x = *(guint32 *)(e->data + f->offset_root);
 637     if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
 638       return (unsigned long) (revFlag ? GUINT32_FROM_BE(x): x);
 639     else
 640       return (unsigned long) (revFlag ? GUINT32_FROM_LE(x): x);
 641   }else if(f->field_size == 8){
 642     guint64 x = *(guint64 *)(e->data + f->offset_root);
 643     if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
 644       return (unsigned long) (revFlag ? GUINT64_FROM_BE(x): x);
 645     else
 646       return (unsigned long) (revFlag ? GUINT64_FROM_LE(x): x);
 647   }
 648   g_critical("ltt_event_get_long_unsigned : field size %i unknown", f->field_size);
 649   return 0;
 650 }
 651
 652 long int ltt_event_get_long_int(LttEvent *e, LttField *f)
 653 {
 654   int revFlag = e->tracefile->trace->my_arch_endian ==
 655                 e->tracefile->trace->system_description->endian ? 0:1;
 656
 657   g_assert( f->field_type->type_class == LTT_INT);
 658
 659   if(f->field_size == 1){
 660     gint8 x = *(gint8 *)(e->data + f->offset_root);
 661     return (long) x;
 662   }else if(f->field_size == 2){
 663     gint16 x = *(gint16 *)(e->data + f->offset_root);
 664     if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
 665       return (long) (revFlag ? GINT16_FROM_BE(x): x);
 666     else
 667       return (long) (revFlag ? GINT16_FROM_LE(x): x);
 668   }else if(f->field_size == 4){
 669     gint32 x = *(gint32 *)(e->data + f->offset_root);
 670     if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
 671       return (long) (revFlag ? GINT32_FROM_BE(x): x);
 672     else
 673       return (long) (revFlag ? GINT32_FROM_LE(x): x);
 674   }else if(f->field_size == 8){
 675     gint64 x = *(gint64 *)(e->data + f->offset_root);
 676     if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
 677       return (long) (revFlag ? GINT64_FROM_BE(x): x);
 678     else
 679       return (long) (revFlag ? GINT64_FROM_LE(x): x);
 680   }
 681   g_critical("ltt_event_get_long_int : field size %i unknown", f->field_size);
 682   return 0;
 683 }
 684
 685 float ltt_event_get_float(LttEvent *e, LttField *f)
 686 {
 687   int revFlag = e->tracefile->trace->my_arch_endian ==
 688                 e->tracefile->trace->system_description->endian ? 0:1;
 689
 690   g_assert(f->field_type->type_class == LTT_FLOAT && f->field_size == 4);
 691
 692   if(revFlag == 0) return *(float *)(e->data + f->offset_root);
 693   else{
 694     guint32 aInt;
 695     memcpy((void*)&aInt, e->data + f->offset_root, 4);
 696     aInt = ___swab32(aInt);
 697     return ((float)aInt);
 698   }
 699 }
 700
 701 double ltt_event_get_double(LttEvent *e, LttField *f)
 702 {
 703   int revFlag = e->tracefile->trace->my_arch_endian ==
 704                 e->tracefile->trace->system_description->endian ? 0:1;
 705
 706   g_assert(f->field_type->type_class == LTT_FLOAT && f->field_size == 8);
 707
 708   if(revFlag == 0) return *(double *)(e->data + f->offset_root);
 709   else{
 710     guint64 aInt;
 711     memcpy((void*)&aInt, e->data + f->offset_root, 8);
 712     aInt = ___swab64(aInt);
 713     return ((double)aInt);
 714   }
 715 }
 716
 717 /*****************************************************************************
 718  * The string obtained is only valid until the next read from
 719  * the same tracefile.
 720  ****************************************************************************/
 721
 722 char *ltt_event_get_string(LttEvent *e, LttField *f)
 723 {
 724   g_assert(f->field_type->type_class == LTT_STRING);
 725
 726   return (char*)g_strdup((char*)(e->data + f->offset_root));
 727 }