449cb9d7 |
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 | |
6cd62ccf |
19 | #include <stdio.h> |
20 | #include <asm/types.h> |
21 | #include <linux/byteorder/swab.h> |
a5dcde2f |
22 | |
6cd62ccf |
23 | #include "parser.h" |
a5dcde2f |
24 | #include <ltt/ltt.h> |
25 | #include "ltt-private.h" |
6cd62ccf |
26 | #include <ltt/event.h> |
a5dcde2f |
27 | #include <ltt/trace.h> |
6cd62ccf |
28 | |
908f42fa |
29 | /***************************************************************************** |
30 | *Function name |
31 | * ltt_event_refresh_fields : refresh fields of an event |
32 | *Input params |
33 | * offsetRoot : offset from the root |
34 | * offsetParent : offset from the parrent |
35 | * fld : field |
36 | * evD : event data |
37 | *Return value |
38 | * int : size of the field |
39 | ****************************************************************************/ |
40 | |
41 | int ltt_event_refresh_fields(int offsetRoot,int offsetParent, |
42 | LttField * fld, void *evD) |
43 | { |
44 | int size, size1, element_number, i, offset1, offset2; |
45 | LttType * type = fld->field_type; |
46 | |
47 | if(type->type_class != LTT_STRUCT && type->type_class != LTT_ARRAY && |
48 | type->type_class != LTT_SEQUENCE && type->type_class != LTT_STRING){ |
49 | size = fld->field_size; |
50 | }else if(type->type_class == LTT_ARRAY){ |
51 | element_number = (int) type->element_number; |
52 | if(fld->field_fixed == 0){// has string or sequence |
53 | size = 0; |
54 | for(i=0;i<element_number;i++){ |
55 | size += ltt_event_refresh_fields(offsetRoot+size,size, |
56 | fld->child[0], evD+size); |
57 | } |
58 | }else size = fld->field_size; |
59 | }else if(type->type_class == LTT_SEQUENCE){ |
60 | size1 = fld->sequ_number_size; |
61 | element_number = getIntNumber(size1,evD); |
62 | type->element_number = element_number; |
63 | if(fld->element_size > 0){ |
64 | size = element_number * fld->element_size; |
65 | }else{//sequence has string or sequence |
66 | size = 0; |
67 | for(i=0;i<element_number;i++){ |
68 | size += ltt_event_refresh_fields(offsetRoot+size+size1,size+size1, |
69 | fld->child[0], evD+size+size1); |
70 | } |
71 | size += size1; |
72 | } |
73 | }else if(type->type_class == LTT_STRING){ |
74 | size = strlen((char*)evD) + 1; //include end : '\0' |
75 | }else if(type->type_class == LTT_STRUCT){ |
76 | element_number = (int) type->element_number; |
77 | if(fld->field_fixed == 0){ |
78 | offset1 = offsetRoot; |
79 | offset2 = 0; |
80 | for(i=0;i<element_number;i++){ |
81 | size=ltt_event_refresh_fields(offset1,offset2,fld->child[i],evD+offset2); |
82 | offset1 += size; |
83 | offset2 += size; |
84 | } |
85 | size = offset2; |
86 | }else size = fld->field_size; |
87 | } |
88 | |
89 | fld->offset_root = offsetRoot; |
90 | fld->offset_parent = offsetParent; |
91 | fld->fixed_root = (offsetRoot==-1) ? 0 : 1; |
92 | fld->fixed_parent = (offsetParent==-1) ? 0 : 1; |
93 | fld->field_size = size; |
94 | |
95 | return size; |
96 | } |
97 | |
6cd62ccf |
98 | /***************************************************************************** |
99 | *Function name |
963b5f2d |
100 | * ltt_event_eventtype_id: get event type id |
101 | * (base id + position of the event) |
6cd62ccf |
102 | *Input params |
963b5f2d |
103 | * e : an instance of an event type |
6cd62ccf |
104 | *Return value |
963b5f2d |
105 | * unsigned : event type id |
6cd62ccf |
106 | ****************************************************************************/ |
107 | |
963b5f2d |
108 | unsigned ltt_event_eventtype_id(LttEvent *e) |
6cd62ccf |
109 | { |
110 | return (unsigned) e->event_id; |
111 | } |
112 | |
113 | /***************************************************************************** |
114 | *Function name |
115 | * ltt_event_facility : get the facility of the event |
116 | *Input params |
117 | * e : an instance of an event type |
118 | *Return value |
963b5f2d |
119 | * LttFacility * : the facility of the event |
6cd62ccf |
120 | ****************************************************************************/ |
121 | |
963b5f2d |
122 | LttFacility *ltt_event_facility(LttEvent *e) |
6cd62ccf |
123 | { |
963b5f2d |
124 | LttTrace * trace = e->tracefile->trace; |
125 | unsigned id = e->event_id; |
126 | return ltt_trace_facility_by_id(trace,id); |
6cd62ccf |
127 | } |
128 | |
129 | /***************************************************************************** |
130 | *Function name |
131 | * ltt_event_eventtype : get the event type of the event |
132 | *Input params |
133 | * e : an instance of an event type |
134 | *Return value |
963b5f2d |
135 | * LttEventType * : the event type of the event |
6cd62ccf |
136 | ****************************************************************************/ |
137 | |
963b5f2d |
138 | LttEventType *ltt_event_eventtype(LttEvent *e) |
6cd62ccf |
139 | { |
963b5f2d |
140 | LttFacility* facility = ltt_event_facility(e); |
141 | if(!facility) return NULL; |
142 | return facility->events[e->event_id - facility->base_id]; |
6cd62ccf |
143 | } |
144 | |
145 | /***************************************************************************** |
146 | *Function name |
963b5f2d |
147 | * ltt_event_field : get the root field of the event |
6cd62ccf |
148 | *Input params |
963b5f2d |
149 | * e : an instance of an event type |
6cd62ccf |
150 | *Return value |
963b5f2d |
151 | * LttField * : the root field of the event |
6cd62ccf |
152 | ****************************************************************************/ |
153 | |
963b5f2d |
154 | LttField *ltt_event_field(LttEvent *e) |
6cd62ccf |
155 | { |
908f42fa |
156 | LttField * field; |
963b5f2d |
157 | LttEventType * event_type = ltt_event_eventtype(e); |
158 | if(!event_type) return NULL; |
908f42fa |
159 | field = event_type->root_field; |
a2331fa0 |
160 | if(!field) return NULL; |
908f42fa |
161 | |
162 | //check if the field need refresh |
163 | if(e->which_block != event_type->latest_block || |
164 | e->which_event != event_type->latest_event){ |
165 | |
166 | event_type->latest_block = e->which_block; |
167 | event_type->latest_event = e->which_event; |
168 | |
169 | if(field->field_fixed == 1)return field; |
170 | |
171 | //refresh the field |
172 | ltt_event_refresh_fields(0, 0, field, e->data); |
173 | } |
174 | return field; |
6cd62ccf |
175 | } |
176 | |
177 | /***************************************************************************** |
178 | *Function name |
963b5f2d |
179 | * ltt_event_time : get the time of the event |
6cd62ccf |
180 | *Input params |
181 | * e : an instance of an event type |
182 | *Return value |
963b5f2d |
183 | * LttTime : the time of the event |
6cd62ccf |
184 | ****************************************************************************/ |
185 | |
963b5f2d |
186 | LttTime ltt_event_time(LttEvent *e) |
6cd62ccf |
187 | { |
963b5f2d |
188 | return e->event_time; |
6cd62ccf |
189 | } |
190 | |
191 | /***************************************************************************** |
192 | *Function name |
963b5f2d |
193 | * ltt_event_time : get the cycle count of the event |
6cd62ccf |
194 | *Input params |
195 | * e : an instance of an event type |
196 | *Return value |
963b5f2d |
197 | * LttCycleCount : the cycle count of the event |
6cd62ccf |
198 | ****************************************************************************/ |
199 | |
963b5f2d |
200 | LttCycleCount ltt_event_cycle_count(LttEvent *e) |
6cd62ccf |
201 | { |
963b5f2d |
202 | return e->event_cycle_count; |
6cd62ccf |
203 | } |
204 | |
80da81ad |
205 | /***************************************************************************** |
206 | *Function name |
207 | * ltt_event_position : get the event's position |
208 | *Input params |
209 | * e : an instance of an event type |
210 | * ep : a pointer to event's position structure |
211 | ****************************************************************************/ |
212 | |
213 | void ltt_event_position(LttEvent *e, LttEventPosition *ep) |
214 | { |
215 | ep->block_num = e->which_block; |
216 | ep->event_num = e->which_event; |
217 | ep->event_time = e->event_time; |
218 | ep->event_cycle_count = e->event_cycle_count; |
219 | ep->heart_beat_number = e->tracefile->cur_heart_beat_number; |
e4eced0f |
220 | ep->old_position = FALSE; |
80da81ad |
221 | ep->event_offset = e->data - e->tracefile->buffer - EVENT_HEADER_SIZE ; |
e4eced0f |
222 | ep->tf = e->tracefile; |
80da81ad |
223 | } |
224 | |
a5dcde2f |
225 | LttEventPosition * ltt_event_position_new() |
226 | { |
227 | return g_new(LttEventPosition, 1); |
228 | } |
229 | |
80da81ad |
230 | /***************************************************************************** |
231 | *Function name |
232 | * ltt_event_position_get : get the block number and index of the event |
233 | *Input params |
234 | * ep : a pointer to event's position structure |
235 | * block_number : the block number of the event |
236 | * index_in_block : the index of the event within the block |
237 | ****************************************************************************/ |
238 | |
239 | void ltt_event_position_get(LttEventPosition *ep, |
e4eced0f |
240 | unsigned *block_number, unsigned *index_in_block, LttTracefile ** tf) |
80da81ad |
241 | { |
242 | *block_number = ep->block_num; |
243 | *index_in_block = ep->event_num; |
e4eced0f |
244 | *tf = ep->tf; |
80da81ad |
245 | } |
246 | |
247 | /***************************************************************************** |
248 | *Function name |
249 | * ltt_event_position_set : set the block number and index of the event |
250 | *Input params |
251 | * ep : a pointer to event's position structure |
252 | * block_number : the block number of the event |
253 | * index_in_block : the index of the event within the block |
254 | ****************************************************************************/ |
255 | |
256 | void ltt_event_position_set(LttEventPosition *ep, |
257 | unsigned block_number, unsigned index_in_block) |
258 | { |
259 | ep->block_num = block_number; |
e4eced0f |
260 | ep->event_num = index_in_block; |
80da81ad |
261 | } |
262 | |
96da5c0d |
263 | /***************************************************************************** |
264 | * Function name |
265 | * ltt_event_position_compare : compare two positions |
266 | * Input params |
267 | * ep1 : a pointer to event's position structure |
268 | * ep2 : a pointer to event's position structure |
269 | * Return |
270 | * -1 is ep1 < ep2 |
271 | * 1 if ep1 > ep2 |
272 | * 0 if ep1 == ep2 |
273 | ****************************************************************************/ |
274 | |
275 | |
276 | gint ltt_event_position_compare(const LttEventPosition *ep1, |
277 | const LttEventPosition *ep2) |
278 | { |
279 | if(ep1->tf != ep2->tf) |
280 | g_error("ltt_event_position_compare on different tracefiles makes no sense"); |
281 | if(ep1->block_num < ep2->block_num) |
282 | return -1; |
283 | if(ep1->block_num > ep2->block_num) |
284 | return 1; |
285 | if(ep1->event_num < ep2->event_num) |
286 | return -1; |
287 | if(ep1->event_num > ep2->event_num) |
288 | return 1; |
289 | return 0; |
290 | } |
291 | |
292 | /***************************************************************************** |
293 | * Function name |
294 | * ltt_event_event_position_compare : compare two positions, one in event, |
295 | * other in position opaque structure. |
296 | * Input params |
297 | * event : a pointer to event structure |
298 | * ep : a pointer to event's position structure |
299 | * Return |
300 | * -1 is event < ep |
301 | * 1 if event > ep |
302 | * 0 if event == ep |
303 | ****************************************************************************/ |
304 | |
305 | gint ltt_event_event_position_compare(const LttEvent *event, |
306 | const LttEventPosition *ep) |
307 | { |
0dfebcb9 |
308 | if(event->tracefile != ep->tf) |
96da5c0d |
309 | g_error("ltt_event_position_compare on different tracefiles makes no sense"); |
0dfebcb9 |
310 | if(event->which_block < ep->block_num) |
96da5c0d |
311 | return -1; |
0dfebcb9 |
312 | if(event->which_block > ep->block_num) |
96da5c0d |
313 | return 1; |
0dfebcb9 |
314 | if(event->which_event < ep->event_num) |
96da5c0d |
315 | return -1; |
0dfebcb9 |
316 | if(event->which_event > ep->event_num) |
96da5c0d |
317 | return 1; |
318 | return 0; |
319 | } |
320 | |
321 | |
322 | |
6cd62ccf |
323 | /***************************************************************************** |
324 | *Function name |
963b5f2d |
325 | * ltt_event_cpu_i: get the cpu id where the event happens |
6cd62ccf |
326 | *Input params |
327 | * e : an instance of an event type |
328 | *Return value |
963b5f2d |
329 | * unsigned : the cpu id |
6cd62ccf |
330 | ****************************************************************************/ |
331 | |
963b5f2d |
332 | unsigned ltt_event_cpu_id(LttEvent *e) |
dd691a2e |
333 | { |
334 | char * c1, * c2, * c3; |
335 | c1 = strrchr(e->tracefile->name,'\\'); |
336 | c2 = strrchr(e->tracefile->name,'/'); |
337 | if(c1 == NULL && c2 == NULL){ |
338 | return (unsigned)atoi(e->tracefile->name); |
339 | }else if(c1 == NULL){ |
340 | c2++; |
341 | return (unsigned)atoi(c2); |
342 | }else if(c2 == NULL){ |
343 | c1++; |
344 | return (unsigned)atoi(c1); |
345 | }else{ |
346 | c3 = (c1 > c2) ? c1 : c2; |
347 | c3++; |
348 | return (unsigned)atoi(c3); |
349 | } |
6cd62ccf |
350 | } |
351 | |
352 | /***************************************************************************** |
353 | *Function name |
354 | * ltt_event_data : get the raw data for the event |
355 | *Input params |
356 | * e : an instance of an event type |
357 | *Return value |
358 | * void * : pointer to the raw data for the event |
359 | ****************************************************************************/ |
360 | |
963b5f2d |
361 | void *ltt_event_data(LttEvent *e) |
6cd62ccf |
362 | { |
363 | return e->data; |
364 | } |
365 | |
366 | /***************************************************************************** |
367 | *Function name |
368 | * ltt_event_field_element_number |
369 | * : The number of elements in a sequence field is specific |
370 | * to each event. This function returns the number of |
371 | * elements for an array or sequence field in an event. |
372 | *Input params |
908f42fa |
373 | * e : an instance of an event type |
6cd62ccf |
374 | * f : a field of the instance |
375 | *Return value |
376 | * unsigned : the number of elements for an array/sequence field |
377 | ****************************************************************************/ |
378 | |
963b5f2d |
379 | unsigned ltt_event_field_element_number(LttEvent *e, LttField *f) |
6cd62ccf |
380 | { |
381 | if(f->field_type->type_class != LTT_ARRAY && |
382 | f->field_type->type_class != LTT_SEQUENCE) |
383 | return 0; |
908f42fa |
384 | |
385 | if(f->field_type->type_class == LTT_ARRAY) |
386 | return f->field_type->element_number; |
387 | return (unsigned) getIntNumber(f->sequ_number_size, e + f->offset_root); |
6cd62ccf |
388 | } |
389 | |
390 | /***************************************************************************** |
391 | *Function name |
392 | * ltt_event_field_element_select |
393 | * : Set the currently selected element for a sequence or |
394 | * array field |
395 | *Input params |
908f42fa |
396 | * e : an instance of an event type |
6cd62ccf |
397 | * f : a field of the instance |
398 | * i : the ith element |
6cd62ccf |
399 | ****************************************************************************/ |
400 | |
963b5f2d |
401 | void ltt_event_field_element_select(LttEvent *e, LttField *f, unsigned i) |
6cd62ccf |
402 | { |
908f42fa |
403 | unsigned element_number; |
404 | LttField *fld; |
405 | int k, size; |
406 | void *evD; |
407 | |
408 | if(f->field_type->type_class != LTT_ARRAY && |
6cd62ccf |
409 | f->field_type->type_class != LTT_SEQUENCE) |
908f42fa |
410 | return ; |
411 | |
412 | element_number = ltt_event_field_element_number(e,f); |
89d4760c |
413 | if((element_number-1) < i || i < 0) return; |
908f42fa |
414 | |
415 | fld = f->child[0]; |
416 | |
417 | evD = e->data + f->offset_root; |
418 | size = 0; |
419 | for(k=0;k<i;k++){ |
420 | size += ltt_event_refresh_fields(f->offset_root+size,size, fld, evD+size); |
421 | } |
6cd62ccf |
422 | |
908f42fa |
423 | f->current_element = i - 1; |
6cd62ccf |
424 | } |
425 | |
426 | /***************************************************************************** |
427 | * These functions extract data from an event after architecture specific |
428 | * conversions |
429 | ****************************************************************************/ |
430 | |
963b5f2d |
431 | unsigned ltt_event_get_unsigned(LttEvent *e, LttField *f) |
6cd62ccf |
432 | { |
963b5f2d |
433 | int revFlag = e->tracefile->trace->my_arch_endian == |
434 | e->tracefile->trace->system_description->endian ? 0:1; |
435 | LttTypeEnum t = f->field_type->type_class; |
6cd62ccf |
436 | |
c687f6c8 |
437 | if(t != LTT_UINT && t != LTT_ENUM) |
6cd62ccf |
438 | g_error("The type of the field is not unsigned int\n"); |
439 | |
b7b36242 |
440 | if(f->field_size == 1){ |
cbd41522 |
441 | guint8 x = *(guint8 *)(e->data + f->offset_root); |
b7b36242 |
442 | return (unsigned int) x; |
443 | }else if(f->field_size == 2){ |
cbd41522 |
444 | guint16 x = *(guint16 *)(e->data + f->offset_root); |
445 | if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN) |
446 | return (unsigned int) (revFlag ? GUINT16_FROM_BE(x): x); |
447 | else |
448 | return (unsigned int) (revFlag ? GUINT16_FROM_LE(x): x); |
b7b36242 |
449 | }else if(f->field_size == 4){ |
cbd41522 |
450 | guint32 x = *(guint32 *)(e->data + f->offset_root); |
451 | if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN) |
452 | return (unsigned int) (revFlag ? GUINT32_FROM_BE(x): x); |
453 | else |
454 | return (unsigned int) (revFlag ? GUINT32_FROM_LE(x): x); |
b7b36242 |
455 | }else if(f->field_size == 8){ |
cbd41522 |
456 | guint64 x = *(guint64 *)(e->data + f->offset_root); |
457 | if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN) |
458 | return (unsigned int) (revFlag ? GUINT64_FROM_BE(x): x); |
459 | else |
460 | return (unsigned int) (revFlag ? GUINT64_FROM_LE(x): x); |
6cd62ccf |
461 | } |
462 | } |
463 | |
963b5f2d |
464 | int ltt_event_get_int(LttEvent *e, LttField *f) |
6cd62ccf |
465 | { |
963b5f2d |
466 | int revFlag = e->tracefile->trace->my_arch_endian == |
467 | e->tracefile->trace->system_description->endian ? 0:1; |
6cd62ccf |
468 | |
469 | if(f->field_type->type_class != LTT_INT) |
470 | g_error("The type of the field is not int\n"); |
471 | |
b7b36242 |
472 | if(f->field_size == 1){ |
cbd41522 |
473 | gint8 x = *(gint8 *)(e->data + f->offset_root); |
b7b36242 |
474 | return (int) x; |
475 | }else if(f->field_size == 2){ |
cbd41522 |
476 | gint16 x = *(gint16 *)(e->data + f->offset_root); |
477 | if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN) |
478 | return (int) (revFlag ? GINT16_FROM_BE(x): x); |
479 | else |
480 | return (int) (revFlag ? GINT16_FROM_LE(x): x); |
b7b36242 |
481 | }else if(f->field_size == 4){ |
cbd41522 |
482 | gint32 x = *(gint32 *)(e->data + f->offset_root); |
483 | if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN) |
484 | return (int) (revFlag ? GINT32_FROM_BE(x): x); |
485 | else |
486 | return (int) (revFlag ? GINT32_FROM_LE(x): x); |
b7b36242 |
487 | }else if(f->field_size == 8){ |
cbd41522 |
488 | gint64 x = *(gint64 *)(e->data + f->offset_root); |
489 | if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN) |
490 | return (int) (revFlag ? GINT64_FROM_BE(x): x); |
491 | else |
492 | return (int) (revFlag ? GINT64_FROM_LE(x): x); |
6cd62ccf |
493 | } |
494 | } |
495 | |
963b5f2d |
496 | unsigned long ltt_event_get_long_unsigned(LttEvent *e, LttField *f) |
6cd62ccf |
497 | { |
963b5f2d |
498 | int revFlag = e->tracefile->trace->my_arch_endian == |
499 | e->tracefile->trace->system_description->endian ? 0:1; |
500 | LttTypeEnum t = f->field_type->type_class; |
6cd62ccf |
501 | |
c687f6c8 |
502 | if(t != LTT_UINT && t != LTT_ENUM) |
6cd62ccf |
503 | g_error("The type of the field is not unsigned long\n"); |
504 | |
b7b36242 |
505 | if(f->field_size == 1){ |
cbd41522 |
506 | guint8 x = *(guint8 *)(e->data + f->offset_root); |
b7b36242 |
507 | return (unsigned long) x; |
508 | }else if(f->field_size == 2){ |
cbd41522 |
509 | guint16 x = *(guint16 *)(e->data + f->offset_root); |
510 | if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN) |
511 | return (unsigned long) (revFlag ? GUINT16_FROM_BE(x): x); |
512 | else |
513 | return (unsigned long) (revFlag ? GUINT16_FROM_LE(x): x); |
b7b36242 |
514 | }else if(f->field_size == 4){ |
cbd41522 |
515 | guint32 x = *(guint32 *)(e->data + f->offset_root); |
516 | if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN) |
517 | return (unsigned long) (revFlag ? GUINT32_FROM_BE(x): x); |
518 | else |
519 | return (unsigned long) (revFlag ? GUINT32_FROM_LE(x): x); |
b7b36242 |
520 | }else if(f->field_size == 8){ |
cbd41522 |
521 | guint64 x = *(guint64 *)(e->data + f->offset_root); |
522 | if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN) |
523 | return (unsigned long) (revFlag ? GUINT64_FROM_BE(x): x); |
524 | else |
525 | return (unsigned long) (revFlag ? GUINT64_FROM_LE(x): x); |
6cd62ccf |
526 | } |
527 | } |
528 | |
963b5f2d |
529 | long int ltt_event_get_long_int(LttEvent *e, LttField *f) |
6cd62ccf |
530 | { |
963b5f2d |
531 | int revFlag = e->tracefile->trace->my_arch_endian == |
532 | e->tracefile->trace->system_description->endian ? 0:1; |
6cd62ccf |
533 | |
534 | if( f->field_type->type_class != LTT_INT) |
535 | g_error("The type of the field is not long int\n"); |
536 | |
b7b36242 |
537 | if(f->field_size == 1){ |
cbd41522 |
538 | gint8 x = *(gint8 *)(e->data + f->offset_root); |
b7b36242 |
539 | return (long) x; |
540 | }else if(f->field_size == 2){ |
cbd41522 |
541 | gint16 x = *(gint16 *)(e->data + f->offset_root); |
542 | if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN) |
543 | return (long) (revFlag ? GINT16_FROM_BE(x): x); |
544 | else |
545 | return (long) (revFlag ? GINT16_FROM_LE(x): x); |
b7b36242 |
546 | }else if(f->field_size == 4){ |
cbd41522 |
547 | gint32 x = *(gint32 *)(e->data + f->offset_root); |
548 | if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN) |
549 | return (long) (revFlag ? GINT32_FROM_BE(x): x); |
550 | else |
551 | return (long) (revFlag ? GINT32_FROM_LE(x): x); |
b7b36242 |
552 | }else if(f->field_size == 8){ |
cbd41522 |
553 | gint64 x = *(gint64 *)(e->data + f->offset_root); |
554 | if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN) |
555 | return (long) (revFlag ? GINT64_FROM_BE(x): x); |
556 | else |
557 | return (long) (revFlag ? GINT64_FROM_LE(x): x); |
6cd62ccf |
558 | } |
559 | } |
560 | |
963b5f2d |
561 | float ltt_event_get_float(LttEvent *e, LttField *f) |
6cd62ccf |
562 | { |
963b5f2d |
563 | int revFlag = e->tracefile->trace->my_arch_endian == |
564 | e->tracefile->trace->system_description->endian ? 0:1; |
6cd62ccf |
565 | |
566 | if(f->field_type->type_class != LTT_FLOAT || |
567 | (f->field_type->type_class == LTT_FLOAT && f->field_size != 4)) |
568 | g_error("The type of the field is not float\n"); |
569 | |
570 | if(revFlag == 0) return *(float *)(e->data + f->offset_root); |
571 | else{ |
cbd41522 |
572 | guint32 aInt; |
6cd62ccf |
573 | memcpy((void*)&aInt, e->data + f->offset_root, 4); |
574 | aInt = ___swab32(aInt); |
575 | return *((float*)&aInt); |
576 | } |
577 | } |
578 | |
963b5f2d |
579 | double ltt_event_get_double(LttEvent *e, LttField *f) |
6cd62ccf |
580 | { |
963b5f2d |
581 | int revFlag = e->tracefile->trace->my_arch_endian == |
582 | e->tracefile->trace->system_description->endian ? 0:1; |
6cd62ccf |
583 | |
584 | if(f->field_type->type_class != LTT_FLOAT || |
585 | (f->field_type->type_class == LTT_FLOAT && f->field_size != 8)) |
586 | g_error("The type of the field is not double\n"); |
587 | |
588 | if(revFlag == 0) return *(double *)(e->data + f->offset_root); |
589 | else{ |
cbd41522 |
590 | guint64 aInt; |
6cd62ccf |
591 | memcpy((void*)&aInt, e->data + f->offset_root, 8); |
592 | aInt = ___swab64(aInt); |
593 | return *((double *)&aInt); |
594 | } |
595 | } |
596 | |
597 | /***************************************************************************** |
598 | * The string obtained is only valid until the next read from |
908f42fa |
599 | * the same tracefile. |
6cd62ccf |
600 | ****************************************************************************/ |
601 | |
963b5f2d |
602 | char *ltt_event_get_string(LttEvent *e, LttField *f) |
6cd62ccf |
603 | { |
604 | if(f->field_type->type_class != LTT_STRING) |
605 | g_error("The field contains no string\n"); |
606 | return (char*)g_strdup((char*)(e->data + f->offset_root)); |
607 | } |