projects / babeltrace.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Add CTFVisitor implementation
[babeltrace.git] / converter / nexus / CTFLogVisitor.cpp
1 /*
2 * Copyright (C) - 2013 Christian Babeux <christian.babeux@efficios.com>
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a copy
5 * of this software and associated documentation files (the "Software"), to deal
6 * in the Software without restriction, including without limitation the rights
7 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 * copies of the Software, and to permit persons to whom the Software is
9 * furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
20 * IN THE SOFTWARE.
21 */
22
23 #include <cassert>
24 #include <sstream>
25 #include <utility>
26 #include "CTFLogVisitor.h"
27 #include "NxMessageVisitor.h"
28 #include "NxMessage.h"
29
30 using std::map;
31 using std::string;
32
33 namespace {
34 /* Types */
35 struct bt_ctf_field_type *uint32_bin_type;
36 struct bt_ctf_field_type *uint32_oct_type;
37 struct bt_ctf_field_type *uint32_dec_type;
38 struct bt_ctf_field_type *uint32_hex_type;
39
40 struct bt_ctf_field_type *uint64_bin_type;
41 struct bt_ctf_field_type *uint64_oct_type;
42 struct bt_ctf_field_type *uint64_dec_type;
43 struct bt_ctf_field_type *uint64_hex_type;
44
45 struct bt_ctf_field_type *string_type;
46 }
47
48 CTFLogVisitor::CTFIntegerField::CTFIntegerField(const string &name,
49 uint32_t value,
50 enum bt_ctf_integer_base base)
51 {
52 struct bt_ctf_field_type *type;
53
54 switch (base)
55 {
56 case BT_CTF_INTEGER_BASE_BINARY:
57 type = uint32_bin_type;
58 break;
59 case BT_CTF_INTEGER_BASE_OCTAL:
60 type = uint32_oct_type;
61 break;
62 case BT_CTF_INTEGER_BASE_DECIMAL:
63 type = uint32_dec_type;
64 break;
65 case BT_CTF_INTEGER_BASE_HEXADECIMAL:
66 type = uint32_hex_type;
67 break;
68 default:
69 assert(false);
70 break;
71 };
72
73 create_unsigned_field(name, type, value);
74 }
75
76 CTFLogVisitor::CTFIntegerField::CTFIntegerField(const string &name,
77 uint64_t value,
78 enum bt_ctf_integer_base base)
79 {
80 struct bt_ctf_field_type *type;
81
82 switch (base)
83 {
84 case BT_CTF_INTEGER_BASE_BINARY:
85 type = uint64_bin_type;
86 break;
87 case BT_CTF_INTEGER_BASE_OCTAL:
88 type = uint64_oct_type;
89 break;
90 case BT_CTF_INTEGER_BASE_DECIMAL:
91 type = uint64_dec_type;
92 break;
93 case BT_CTF_INTEGER_BASE_HEXADECIMAL:
94 type = uint64_hex_type;
95 break;
96 default:
97 assert(false);
98 break;
99 };
100
101 create_unsigned_field(name, type, value);
102 }
103
104 void CTFLogVisitor::CTFIntegerField::create_unsigned_field(const string &name,
105 struct bt_ctf_field_type *type,
106 uint64_t value)
107 {
108 int ret = 0;
109 struct bt_ctf_field *field = NULL;
110
111 assert(type);
112
113 field = bt_ctf_field_create(type);
114 assert(field);
115
116 ret = bt_ctf_field_unsigned_integer_set_value(field, value);
117 assert(!ret);
118
119 name_ = name;
120 field_ = field;
121 type_ = type;
122 }
123
124 CTFLogVisitor::CTFStringField::CTFStringField(const string &name,
125 const string &value)
126 {
127 int ret = 0;
128 struct bt_ctf_field *field = NULL;
129
130 field = bt_ctf_field_create(string_type);
131 assert(field);
132
133 ret = bt_ctf_field_string_set_value(field, value.c_str());
134 assert(!ret);
135
136 name_ = name;
137 field_ = field;
138 type_ = string_type;
139 }
140
141 CTFLogVisitor::CTFLogVisitor(const string &trace_path)
142 {
143 int ret = 0;
144 uint64_t default_clock = 1000000000;
145
146 writer_ = bt_ctf_writer_create(trace_path.c_str());
147
148 /* TODO: How can we handle errors in the visitor? */
149 assert(writer_);
150 ret = bt_ctf_writer_add_environment_field(writer_,
151 "converter",
152 "Babeltrace Nexus to CTF");
153 assert(!ret);
154
155 /* Clock */
156
157 /*
158 * TODO: Figure out how to obtain clock frequency and precision
159 * from the traced system.
160 */
161 clock_ = bt_ctf_clock_create("system_clock");
162 assert(clock_);
163
164 ret = bt_ctf_clock_set_description(clock_, "System clock");
165 assert(!ret);
166
167 ret = bt_ctf_clock_set_frequency(clock_, default_clock);
168 assert(!ret);
169
170 ret = bt_ctf_clock_set_is_absolute(clock_, 1);
171 assert(!ret);
172
173 ret = bt_ctf_writer_add_clock(writer_, clock_);
174 assert(!ret);
175
176 /* Stream class */
177 stream_class_ = bt_ctf_stream_class_create("stream0");
178 assert(stream_class_);
179
180 ret = bt_ctf_stream_class_set_clock(stream_class_, clock_);
181 assert(!ret);
182
183 stream_ = bt_ctf_writer_create_stream(writer_, stream_class_);
184 assert(stream_);
185
186 /* Types init */
187 string_type = bt_ctf_field_type_string_create();
188
189 uint32_bin_type = bt_ctf_field_type_integer_create(32);
190 ret = bt_ctf_field_type_integer_set_base(uint32_bin_type,
191 BT_CTF_INTEGER_BASE_BINARY);
192 assert(!ret);
193
194 uint64_bin_type = bt_ctf_field_type_integer_create(64);
195 ret = bt_ctf_field_type_integer_set_base(uint64_bin_type,
196 BT_CTF_INTEGER_BASE_BINARY);
197 assert(!ret);
198
199 uint32_oct_type = bt_ctf_field_type_integer_create(32);
200 ret = bt_ctf_field_type_integer_set_base(uint32_oct_type,
201 BT_CTF_INTEGER_BASE_OCTAL);
202 assert(!ret);
203
204 uint64_oct_type = bt_ctf_field_type_integer_create(64);
205 ret = bt_ctf_field_type_integer_set_base(uint64_oct_type,
206 BT_CTF_INTEGER_BASE_OCTAL);
207 assert(!ret);
208
209 uint32_dec_type = bt_ctf_field_type_integer_create(32);
210 ret = bt_ctf_field_type_integer_set_base(uint32_dec_type,
211 BT_CTF_INTEGER_BASE_DECIMAL);
212 assert(!ret);
213
214 uint64_dec_type = bt_ctf_field_type_integer_create(64);
215 ret = bt_ctf_field_type_integer_set_base(uint64_dec_type,
216 BT_CTF_INTEGER_BASE_DECIMAL);
217 assert(!ret);
218
219 uint32_hex_type = bt_ctf_field_type_integer_create(32);
220 ret = bt_ctf_field_type_integer_set_base(uint32_hex_type,
221 BT_CTF_INTEGER_BASE_HEXADECIMAL);
222 assert(!ret);
223
224 uint64_hex_type = bt_ctf_field_type_integer_create(64);
225 ret = bt_ctf_field_type_integer_set_base(uint64_hex_type,
226 BT_CTF_INTEGER_BASE_HEXADECIMAL);
227 assert(!ret);
228 }
229
230 CTFLogVisitor::~CTFLogVisitor()
231 {
232 /* Free event classes */
233 map<const type_info *, struct bt_ctf_event_class *>::iterator it;
234 for (it = event_class_.begin(); it != event_class_.end(); ++it) {
235 bt_ctf_event_class_put(it->second);
236 }
237
238 /* Free types */
239 bt_ctf_field_type_put(uint32_bin_type);
240 bt_ctf_field_type_put(uint64_bin_type);
241
242 bt_ctf_field_type_put(uint32_oct_type);
243 bt_ctf_field_type_put(uint64_oct_type);
244
245 bt_ctf_field_type_put(uint32_dec_type);
246 bt_ctf_field_type_put(uint64_dec_type);
247
248 bt_ctf_field_type_put(uint32_hex_type);
249 bt_ctf_field_type_put(uint64_hex_type);
250
251 bt_ctf_field_type_put(string_type);
252
253 bt_ctf_clock_put(clock_);
254 bt_ctf_stream_class_put(stream_class_);
255 bt_ctf_stream_put(stream_);
256
257 /* Free writer */
258 bt_ctf_writer_put(writer_);
259 }
260
261 struct bt_ctf_event_class* CTFLogVisitor::create_event_class(const NxMessage *m,
262 const string &name,
263 const CTFFields &fields)
264 {
265 int ret = 0;
266 struct bt_ctf_event_class *event_class = NULL;
267
268 event_class = bt_ctf_event_class_create(name.c_str());
269 assert(event_class);
270
271 for (CTFFields::const_iterator it = fields.begin();
272 it != fields.end();
273 ++it) {
274 const char *name = (*it)->name().c_str();
275 struct bt_ctf_field_type *type = (*it)->type();
276 assert(name);
277 assert(type);
278
279 ret = bt_ctf_event_class_add_field(event_class, type, name);
280 assert(!ret);
281 }
282
283 ret = bt_ctf_stream_class_add_event_class(stream_class_, event_class);
284 assert(!ret);
285
286 event_class_[&typeid(*m)] = event_class;
287
288 return event_class;
289 }
290
291 struct bt_ctf_event_class*
292 CTFLogVisitor::get_event_class(const NxMessage *m) const
293 {
294 struct bt_ctf_event_class *event_class = NULL;
295 map<const type_info *, struct bt_ctf_event_class *>::const_iterator it;
296
297 assert(m);
298
299 it = event_class_.find(&typeid(*m));
300
301 if (it != event_class_.end()) {
302 event_class = it->second;
303 }
304
305 return event_class;
306 }
307
308
309 void CTFLogVisitor::event_set_fields(struct bt_ctf_event *event,
310 const CTFFields &fields) const
311 {
312 assert(event);
313
314 for (CTFFields::const_iterator it = fields.begin();
315 it != fields.end();
316 ++it) {
317 int ret = 0;
318 const char *name = (*it)->name().c_str();
319 bt_ctf_field *field = (*it)->field();
320 assert(name);
321 assert(field);
322
323 ret = bt_ctf_event_set_payload(event, name, field);
324 assert(!ret);
325 }
326 }
327
328 void CTFLogVisitor::append_nexus_message(NxMessage *m,
329 const string &event_name,
330 const CTFFields &fields)
331 {
332 int ret = 0;
333 struct bt_ctf_event_class *event_class = NULL;
334 struct bt_ctf_event *event = NULL;
335
336 assert(m);
337
338 event_class = get_event_class(m);
339
340 if (event_class == NULL) {
341 event_class = create_event_class(m, event_name, fields);
342 }
343
344 event = bt_ctf_event_create(event_class);
345 assert(event);
346
347 event_set_fields(event, fields);
348
349 ret = bt_ctf_stream_append_event(stream_, event);
350 assert(!ret);
351
352 /*
353 * FIXME: There will only be one event per-packet
354 * if we flush for each message.
355 */
356 ret = bt_ctf_stream_flush(stream_);
357 assert(!ret);
358
359 bt_ctf_event_put(event);
360 }
361
362 void CTFLogVisitor::visit(NxDefaultMessage *m)
363 {
364 /*
365 * These messages are treated as "unknown" and their payload
366 * won't be decoded. No need to process them.
367 */
368 useful_visit_ = false;
369 }
370
371 void CTFLogVisitor::visit(NxDebugStatusMessage *m)
372 {
373 /* Default Nexus Message fields */
374 CTFIntegerField tcode ("TCODE", m->tcode());
375 CTFStringField tcode_desc ("TCODE_DESC", m->tcodeString());
376 CTFIntegerField src_id ("SRC_ID", m->sourceId());
377 CTFStringField src_id_desc ("SRC_ID_DESC", string(m->sourceIdString()));
378 CTFIntegerField timestamp ("TIMESTAMP", m->correctedTimestamp());
379
380 /* Nexus Debug Status fields */
381 CTFIntegerField status ("STATUS", m->status(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
382
383 CTFFields fields;
384
385 fields.push_back(&tcode);
386 fields.push_back(&tcode_desc);
387 fields.push_back(&src_id);
388 fields.push_back(&src_id_desc);
389 fields.push_back(&timestamp);
390 fields.push_back(&status);
391
392 append_nexus_message(m, "Nexus Debug Status Message", fields);
393 useful_visit_ = true;
394 }
395
396 void CTFLogVisitor::visit(NxDeviceIDMessage *m)
397 {
398 /* Default Nexus Message fields */
399 CTFIntegerField tcode ("TCODE", m->tcode());
400 CTFStringField tcode_desc ("TCODE_DESC", m->tcodeString());
401 CTFIntegerField src_id ("SRC_ID", m->sourceId());
402 CTFStringField src_id_desc ("SRC_ID_DESC", string(m->sourceIdString()));
403
404 /* TODO: Confirm that Nexus Device ID Message can't have timestamp */
405 /*CTFIntegerField timestamp ("TIMESTAMP", m->correctedTimestamp());*/
406
407 CTFFields fields;
408
409 fields.push_back(&tcode);
410 fields.push_back(&tcode_desc);
411 fields.push_back(&src_id);
412 fields.push_back(&src_id_desc);
413 /*fields.push_back(&timestamp);*/
414
415 append_nexus_message(m, "Nexus Device ID Message", fields);
416 useful_visit_ = true;
417 }
418
419 void CTFLogVisitor::visit(NxOwnershipTraceMessage *m)
420 {
421 /* Default Nexus Message fields */
422 CTFIntegerField tcode ("TCODE", m->tcode());
423 CTFStringField tcode_desc ("TCODE_DESC", m->tcodeString());
424 CTFIntegerField src_id ("SRC_ID", m->sourceId());
425 CTFStringField src_id_desc ("SRC_ID_DESC", string(m->sourceIdString()));
426 CTFIntegerField timestamp ("TIMESTAMP", m->correctedTimestamp());
427
428 /* Nexus Ownership Trace Message fields */
429 CTFIntegerField pid_idx ("PID_INDEX", m->pidIndex(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
430 CTFStringField pid_idx_desc ("PID_INDEX_DESC", string(m->pidIndexString()));
431 CTFIntegerField pid_val ("PID_VALUE", m->pidValue());
432 CTFStringField pid_val_desc ("PID_VALUE_DESC", string(m->pidValueString()));
433
434 CTFFields fields;
435
436 fields.push_back(&tcode);
437 fields.push_back(&tcode_desc);
438 fields.push_back(&src_id);
439 fields.push_back(&src_id_desc);
440 fields.push_back(&timestamp);
441 fields.push_back(&pid_idx);
442 fields.push_back(&pid_idx_desc);
443 fields.push_back(&pid_val);
444 fields.push_back(&pid_val_desc);
445
446 append_nexus_message(m, "Nexus Ownership Trace Message", fields);
447 useful_visit_ = true;
448 }
449
450 void CTFLogVisitor::visit(NxDataAcquisitionMessage *m)
451 {
452 /* Default Nexus Message fields */
453 CTFIntegerField tcode ("TCODE", m->tcode());
454 CTFStringField tcode_desc ("TCODE_DESC", m->tcodeString());
455 CTFIntegerField src_id ("SRC_ID", m->sourceId());
456 CTFStringField src_id_desc ("SRC_ID_DESC", string(m->sourceIdString()));
457 CTFIntegerField timestamp ("TIMESTAMP", m->correctedTimestamp());
458
459 /* Nexus Data Acquisition Message fields */
460 CTFIntegerField id_tag ("IDTAG", m->idtag(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
461 CTFStringField id_tag_desc ("IDTAG_DESC", string(m->idtagString()));
462 CTFIntegerField dq_data ("DQDATA", m->dqdata());
463 CTFStringField dq_data_desc ("DQDATA_DESC", string(m->dqdataString()));
464
465 CTFFields fields;
466
467 fields.push_back(&tcode);
468 fields.push_back(&tcode_desc);
469 fields.push_back(&src_id);
470 fields.push_back(&src_id_desc);
471 fields.push_back(&timestamp);
472 fields.push_back(&id_tag);
473 fields.push_back(&id_tag_desc);
474 fields.push_back(&dq_data);
475 fields.push_back(&dq_data_desc);
476
477 append_nexus_message(m, "Nexus Data Acquisition Message", fields);
478 useful_visit_ = true;
479 }
480
481 void CTFLogVisitor::visit(NxErrorMessage *m)
482 {
483 /* Default Nexus Message fields */
484 CTFIntegerField tcode ("TCODE", m->tcode());
485 CTFStringField tcode_desc ("TCODE_DESC", m->tcodeString());
486 CTFIntegerField src_id ("SRC_ID", m->sourceId());
487 CTFStringField src_id_desc ("SRC_ID_DESC", string(m->sourceIdString()));
488 CTFIntegerField timestamp ("TIMESTAMP", m->correctedTimestamp());
489
490 /* Nexus Error Message fields */
491 CTFIntegerField etype ("ETYPE", m->etype(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
492 CTFStringField etype_desc ("ETYPE_DESC", string(m->etypeString()));
493 CTFIntegerField ecode ("ECODE", m->ecode(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
494 CTFStringField ecode_desc ("ECODE_DESC", string(m->ecodeString()));
495
496 CTFFields fields;
497
498 fields.push_back(&tcode);
499 fields.push_back(&tcode_desc);
500 fields.push_back(&src_id);
501 fields.push_back(&src_id_desc);
502 fields.push_back(&timestamp);
503 fields.push_back(&etype);
504 fields.push_back(&etype_desc);
505 fields.push_back(&ecode);
506 fields.push_back(&ecode_desc);
507
508 append_nexus_message(m, "Nexus Error Message", fields);
509 useful_visit_ = true;
510 }
511
512 void CTFLogVisitor::visit(NxProgramTraceSync *m)
513 {
514 /* Default Nexus Message fields */
515 CTFIntegerField tcode ("TCODE", m->tcode());
516 CTFStringField tcode_desc ("TCODE_DESC", m->tcodeString());
517 CTFIntegerField src_id ("SRC_ID", m->sourceId());
518 CTFStringField src_id_desc ("SRC_ID_DESC", string(m->sourceIdString()));
519 CTFIntegerField timestamp ("TIMESTAMP", m->correctedTimestamp());
520
521 /* Nexus Program Trace Sync fields */
522 CTFIntegerField map ("MAP", m->map(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
523 CTFIntegerField icnt ("ICNT", m->icnt());
524 CTFIntegerField hist ("HIST", m->hist(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
525 CTFIntegerField pc64 ("PC", m->address().address64(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
526 CTFIntegerField pc32 ("PC", m->address().address32(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
527
528 CTFFields fields;
529
530 fields.push_back(&tcode);
531 fields.push_back(&tcode_desc);
532 fields.push_back(&src_id);
533 fields.push_back(&src_id_desc);
534 fields.push_back(&timestamp);
535 fields.push_back(&map);
536 fields.push_back(&icnt);
537 fields.push_back(&hist);
538
539 /*
540 * TODO: Is it possible for pc to change bitness between messages?
541 * If so, we should probably add both fields to the trace.
542 */
543 if (m->address().is64bits()) {
544 fields.push_back(&pc64);
545 } else {
546 fields.push_back(&pc32);
547 }
548
549 append_nexus_message(m, "Nexus Program Trace Sync Message", fields);
550 useful_visit_ = true;
551 }
552
553 void CTFLogVisitor::visit(NxDataTraceWrite *m)
554 {
555 /* Default Nexus Message fields */
556 CTFIntegerField tcode ("TCODE", m->tcode());
557 CTFStringField tcode_desc ("TCODE_DESC", m->tcodeString());
558 CTFIntegerField src_id ("SRC_ID", m->sourceId());
559 CTFStringField src_id_desc ("SRC_ID_DESC", string(m->sourceIdString()));
560 CTFIntegerField timestamp ("TIMESTAMP", m->correctedTimestamp());
561
562 /* Nexus Data Trace Write fields */
563 CTFIntegerField dsz ("DSZ", m->dsz(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
564 CTFStringField dsz_desc ("DSZ_DESC", string(m->dszString()));
565 CTFIntegerField addr ("UADDR", m->addr(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
566 CTFIntegerField data ("DATA", m->data(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
567
568 CTFFields fields;
569
570 fields.push_back(&tcode);
571 fields.push_back(&tcode_desc);
572 fields.push_back(&src_id);
573 fields.push_back(&src_id_desc);
574 fields.push_back(&timestamp);
575 fields.push_back(&dsz);
576 fields.push_back(&dsz_desc);
577 fields.push_back(&addr);
578 fields.push_back(&data);
579
580 append_nexus_message(m, "Nexus Data Trace Write Message", fields);
581 useful_visit_ = true;
582 }
583
584 void CTFLogVisitor::visit(NxDataTraceRead *m)
585 {
586 /* Default Nexus Message fields */
587 CTFIntegerField tcode ("TCODE", m->tcode());
588 CTFStringField tcode_desc ("TCODE_DESC", m->tcodeString());
589 CTFIntegerField src_id ("SRC_ID", m->sourceId());
590 CTFStringField src_id_desc ("SRC_ID_DESC", string(m->sourceIdString()));
591 CTFIntegerField timestamp ("TIMESTAMP", m->correctedTimestamp());
592
593 /* Nexus Data Trace Read fields */
594 CTFIntegerField dsz ("DSZ", m->dsz(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
595 CTFStringField dsz_desc ("DSZ_DESC", string(m->dszString()));
596 CTFIntegerField addr ("UADDR", m->addr(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
597 CTFIntegerField data ("DATA", m->data(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
598
599 CTFFields fields;
600
601 fields.push_back(&tcode);
602 fields.push_back(&tcode_desc);
603 fields.push_back(&src_id);
604 fields.push_back(&src_id_desc);
605 fields.push_back(&timestamp);
606 fields.push_back(&dsz);
607 fields.push_back(&dsz_desc);
608 fields.push_back(&addr);
609 fields.push_back(&data);
610
611 append_nexus_message(m, "Nexus Data Trace Read Message", fields);
612 useful_visit_ = true;
613 }
614
615 void CTFLogVisitor::visit(NxDataTraceWriteSync *m)
616 {
617 /* Default Nexus Message fields */
618 CTFIntegerField tcode ("TCODE", m->tcode());
619 CTFStringField tcode_desc ("TCODE_DESC", m->tcodeString());
620 CTFIntegerField src_id ("SRC_ID", m->sourceId());
621 CTFStringField src_id_desc ("SRC_ID_DESC", string(m->sourceIdString()));
622 CTFIntegerField timestamp ("TIMESTAMP", m->correctedTimestamp());
623
624 /* Nexus Data Trace Write Sync fields */
625 CTFIntegerField dsz ("DSZ", m->dsz(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
626 CTFStringField dsz_desc ("DSZ_DESC", string(m->dszString()));
627 CTFIntegerField addr ("FADDR", m->addr(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
628 CTFIntegerField data ("DATA", m->data(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
629
630 CTFFields fields;
631
632 fields.push_back(&tcode);
633 fields.push_back(&tcode_desc);
634 fields.push_back(&src_id);
635 fields.push_back(&src_id_desc);
636 fields.push_back(&timestamp);
637 fields.push_back(&dsz);
638 fields.push_back(&dsz_desc);
639 fields.push_back(&addr);
640 fields.push_back(&data);
641
642 append_nexus_message(m, "Nexus Data Trace Write Sync Message", fields);
643 useful_visit_ = true;
644 }
645
646 void CTFLogVisitor::visit(NxDataTraceReadSync *m)
647 {
648 /* Default Nexus Message fields */
649 CTFIntegerField tcode ("TCODE", m->tcode());
650 CTFStringField tcode_desc ("TCODE_DESC", m->tcodeString());
651 CTFIntegerField src_id ("SRC_ID", m->sourceId());
652 CTFStringField src_id_desc ("SRC_ID_DESC", string(m->sourceIdString()));
653 CTFIntegerField timestamp ("TIMESTAMP", m->correctedTimestamp());
654
655 /* Nexus Data Trace Read Sync fields */
656 CTFIntegerField dsz ("DSZ", m->dsz(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
657 CTFStringField dsz_desc ("DSZ_DESC", string(m->dszString()));
658 CTFIntegerField addr ("FADDR", m->addr(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
659 CTFIntegerField data ("DATA", m->data(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
660
661 CTFFields fields;
662
663 fields.push_back(&tcode);
664 fields.push_back(&tcode_desc);
665 fields.push_back(&src_id);
666 fields.push_back(&src_id_desc);
667 fields.push_back(&timestamp);
668 fields.push_back(&dsz);
669 fields.push_back(&dsz_desc);
670 fields.push_back(&addr);
671 fields.push_back(&data);
672
673 append_nexus_message(m, "Nexus Data Trace Read Sync Message", fields);
674 useful_visit_ = true;
675 }
676
677 void CTFLogVisitor::visit(NxWatchpointMessage *m)
678 {
679 /* Default Nexus Message fields */
680 CTFIntegerField tcode ("TCODE", m->tcode());
681 CTFStringField tcode_desc ("TCODE_DESC", m->tcodeString());
682 CTFIntegerField src_id ("SRC_ID", m->sourceId());
683 CTFStringField src_id_desc ("SRC_ID_DESC", string(m->sourceIdString()));
684 CTFIntegerField timestamp ("TIMESTAMP", m->correctedTimestamp());
685
686 /* Nexus Watchpoint fields */
687 CTFIntegerField wphit ("WPHIT", m->wphit(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
688 CTFStringField wphit_desc ("WPHIT_DESC", m->wphitString());
689 CTFIntegerField wphit_size ("WPHIT_SIZE", m->wphit_size(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
690
691 CTFFields fields;
692
693 fields.push_back(&tcode);
694 fields.push_back(&tcode_desc);
695 fields.push_back(&src_id);
696 fields.push_back(&src_id_desc);
697 fields.push_back(&timestamp);
698 fields.push_back(&wphit);
699 fields.push_back(&wphit_desc);
700 fields.push_back(&wphit_size);
701
702 append_nexus_message(m, "Nexus Watchpoint Message", fields);
703 useful_visit_ = true;
704 }
705
706 void CTFLogVisitor::visit(NxResourceFullMessage *m)
707 {
708 /* Default Nexus Message fields */
709 CTFIntegerField tcode ("TCODE", m->tcode());
710 CTFStringField tcode_desc ("TCODE_DESC", m->tcodeString());
711 CTFIntegerField src_id ("SRC_ID", m->sourceId());
712 CTFStringField src_id_desc ("SRC_ID_DESC", string(m->sourceIdString()));
713 CTFIntegerField timestamp ("TIMESTAMP", m->correctedTimestamp());
714
715 /* Nexus Ressource Full fields */
716 CTFIntegerField rcode ("RCODE", m->rcode(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
717 CTFStringField rcode_desc ("RCODE_DESC", string(m->rcodeString()));
718 CTFIntegerField rdata ("RDATA", m->rdata(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
719
720 CTFFields fields;
721
722 fields.push_back(&tcode);
723 fields.push_back(&tcode_desc);
724 fields.push_back(&src_id);
725 fields.push_back(&src_id_desc);
726 fields.push_back(&timestamp);
727 fields.push_back(&rcode);
728 fields.push_back(&rcode_desc);
729 fields.push_back(&rdata);
730
731 append_nexus_message(m, "Nexus Ressource Full Message", fields);
732 useful_visit_ = true;
733 }
734
735 void CTFLogVisitor::visit(NxProgramTraceIndirectBranch *m)
736 {
737 /* Default Nexus Message fields */
738 CTFIntegerField tcode ("TCODE", m->tcode());
739 CTFStringField tcode_desc ("TCODE_DESC", m->tcodeString());
740 CTFIntegerField src_id ("SRC_ID", m->sourceId());
741 CTFStringField src_id_desc ("SRC_ID_DESC", string(m->sourceIdString()));
742 CTFIntegerField timestamp ("TIMESTAMP", m->correctedTimestamp());
743
744 /* Nexus Program Trace Indirect Branch fields */
745 CTFIntegerField btype ("BTYPE", m->btype(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
746 CTFStringField btype_desc ("BTYPE_DESC", m->btypeString());
747 CTFIntegerField icnt ("ICNT", m->icnt());
748 CTFIntegerField hist ("HIST", m->hist(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
749 CTFIntegerField uaddr64 ("UADDR", m->address().address64(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
750 CTFIntegerField uaddr32 ("UADDR", m->address().address32(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
751
752 CTFFields fields;
753
754 fields.push_back(&tcode);
755 fields.push_back(&tcode_desc);
756 fields.push_back(&src_id);
757 fields.push_back(&src_id_desc);
758 fields.push_back(&timestamp);
759 fields.push_back(&btype);
760 fields.push_back(&btype_desc);
761 fields.push_back(&icnt);
762 fields.push_back(&hist);
763
764 /*
765 * TODO: Is it possible for uaddr to change bitness between messages?
766 * If so, we should probably add both fields to the trace.
767 */
768 if (m->address().is64bits()) {
769 fields.push_back(&uaddr64);
770 } else {
771 fields.push_back(&uaddr32);
772 }
773
774 append_nexus_message(m, "Nexus Program Trace Indirect Branch Message", fields);
775 useful_visit_ = true;
776 }
777
778 void CTFLogVisitor::visit(NxProgramTraceIndirectBranchSync *m)
779 {
780 /* Default Nexus Message fields */
781 CTFIntegerField tcode ("TCODE", m->tcode());
782 CTFStringField tcode_desc ("TCODE_DESC", m->tcodeString());
783 CTFIntegerField src_id ("SRC_ID", m->sourceId());
784 CTFStringField src_id_desc ("SRC_ID_DESC", string(m->sourceIdString()));
785 CTFIntegerField timestamp ("TIMESTAMP", m->correctedTimestamp());
786
787 /* Nexus Program Trace Indirect Branch Sync fields */
788 CTFIntegerField btype ("BTYPE", m->btype(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
789 CTFStringField btype_desc ("BTYPE_DESC", m->btypeString());
790 CTFIntegerField icnt ("ICNT", m->icnt());
791 CTFIntegerField hist ("HIST", m->hist(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
792 CTFIntegerField faddr64 ("FADDR", m->address().address64(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
793 CTFIntegerField faddr32 ("FADDR", m->address().address32(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
794
795 CTFFields fields;
796
797 fields.push_back(&tcode);
798 fields.push_back(&tcode_desc);
799 fields.push_back(&src_id);
800 fields.push_back(&src_id_desc);
801 fields.push_back(&timestamp);
802 fields.push_back(&btype);
803 fields.push_back(&btype_desc);
804 fields.push_back(&icnt);
805 fields.push_back(&hist);
806
807 /*
808 * TODO: Is it possible for faddr to change bitness between messages?
809 * If so, we should probably add both fields to the trace.
810 */
811 if (m->address().is64bits()) {
812 fields.push_back(&faddr64);
813 } else {
814 fields.push_back(&faddr32);
815 }
816
817 append_nexus_message(m, "Nexus Program Trace Indirect Branch Sync Message", fields);
818 useful_visit_ = true;
819 }
820
821 void CTFLogVisitor::visit(NxProgramTraceCorrelation *m)
822 {
823 /* Default Nexus Message fields */
824 CTFIntegerField tcode ("TCODE", m->tcode());
825 CTFStringField tcode_desc ("TCODE_DESC", m->tcodeString());
826 CTFIntegerField src_id ("SRC_ID", m->sourceId());
827 CTFStringField src_id_desc ("SRC_ID_DESC", string(m->sourceIdString()));
828 CTFIntegerField timestamp ("TIMESTAMP", m->correctedTimestamp());
829
830 /* Nexus Program Trace Correlation fields */
831 CTFIntegerField evcode ("EVCODE", m->evcode(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
832 CTFStringField evcode_desc ("EVCODE_DESC", m->evcodeString());
833 CTFIntegerField icnt ("ICNT", m->icnt());
834 CTFIntegerField cdata ("CDATA", m->cdata(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
835
836 CTFFields fields;
837
838 fields.push_back(&tcode);
839 fields.push_back(&tcode_desc);
840 fields.push_back(&src_id);
841 fields.push_back(&src_id_desc);
842 fields.push_back(&timestamp);
843 fields.push_back(&evcode);
844 fields.push_back(&evcode_desc);
845 fields.push_back(&icnt);
846 fields.push_back(&cdata);
847
848 append_nexus_message(m, "Nexus Program Trace Correlation Message", fields);
849 useful_visit_ = true;
850 }
851
852 void CTFLogVisitor::visit(NxDAMInCircuitTraceMessage *m)
853 {
854 /* Default Nexus Message fields */
855 CTFIntegerField tcode ("TCODE", m->tcode());
856 CTFStringField tcode_desc ("TCODE_DESC", m->tcodeString());
857 CTFIntegerField src_id ("SRC_ID", m->sourceId());
858 CTFStringField src_id_desc ("SRC_ID_DESC", string(m->sourceIdString()));
859 CTFIntegerField timestamp ("TIMESTAMP", m->correctedTimestamp());
860
861 /* Nexus DAM In-Circuit Trace fields */
862 CTFStringField ict_msg_type ("ICT_MSG_TYPE", string(m->ICTMessageType()));
863 CTFIntegerField ddrmid ("DDRMID", m->ddrmid());
864 CTFIntegerField ddrsid ("DDRSID", m->ddrsid());
865 CTFIntegerField ddrtt ("DDRTT", m->ddrtt());
866 CTFStringField ddrtt_desc ("DDRTT_DESC", string(m->ddrttString()));
867 CTFIntegerField ddrsz ("DDRSZ", m->ddrsz());
868 CTFIntegerField faddr ("FADDR", (m->isSyncMessage() ? m->ddraddr() : 0), BT_CTF_INTEGER_BASE_HEXADECIMAL);
869 CTFIntegerField uaddr ("UADDR", (m->isSyncMessage() ? 0 : m->ddraddr()), BT_CTF_INTEGER_BASE_HEXADECIMAL);
870 CTFIntegerField dddiec ("DDDIEC", m->dddiec());
871
872 CTFFields fields;
873
874 fields.push_back(&tcode);
875 fields.push_back(&tcode_desc);
876 fields.push_back(&src_id);
877 fields.push_back(&src_id_desc);
878 fields.push_back(&timestamp);
879 fields.push_back(&ict_msg_type);
880 fields.push_back(&ddrmid);
881 fields.push_back(&ddrsid);
882 fields.push_back(&ddrtt);
883 fields.push_back(&ddrtt_desc);
884 fields.push_back(&ddrsz);
885 fields.push_back(&faddr);
886 fields.push_back(&uaddr);
887 fields.push_back(&dddiec);
888
889 append_nexus_message(m, "Nexus DAM In-Circuit Trace Message", fields);
890 useful_visit_ = true;
891 }
892
893 void CTFLogVisitor::visit(NxCAMInCircuitTraceMessage *m)
894 {
895 useful_visit_ = false;
896 }
897
898 void CTFLogVisitor::visit(NxCDMInCircuitTraceMessage *m)
899 {
900 useful_visit_ = false;
901 }
902
903 void CTFLogVisitor::visit(NxDPQMInCircuitTraceMessage *m)
904 {
905 /* Default Nexus Message fields */
906 CTFIntegerField tcode ("TCODE", m->tcode());
907 CTFStringField tcode_desc ("TCODE_DESC", m->tcodeString());
908 CTFIntegerField src_id ("SRC_ID", m->sourceId());
909 CTFStringField src_id_desc ("SRC_ID_DESC", string(m->sourceIdString()));
910 CTFIntegerField timestamp ("TIMESTAMP", m->correctedTimestamp());
911
912 /* Nexus DPQM In-Circuit Trace fields */
913 CTFStringField ict_msg_type ("ICT_MSG_TYPE", string(m->ICTMessageType()));
914 CTFIntegerField dpdm ("DBG_MARK", m->dpdm());
915 CTFIntegerField fqid ("FQ_ID", m->fqid(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
916 CTFIntegerField cnum ("CH_NUM", m->cnum(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
917 CTFIntegerField pnum ("PORT_NUM", m->pnum());
918 CTFIntegerField ptype ("PORT_TYPE", m->ptype());
919 CTFStringField ptype_desc ("PORT_TYPE_DESC", (m->ptype() ? "Direct Connect" : "Software"));
920 CTFIntegerField qet ("QEVNT_TYPE", m->qet());
921 CTFStringField qet_desc ("QEVNT_TYPE_DESC", string(m->queueEventTypeString()));
922 CTFIntegerField orf ("ORD_REST", m->orf());
923 /* TODO: Does the erf field indicate enqueue operation rejection? */
924 CTFIntegerField erf ("ENQ_REJCT", m->erf());
925 CTFIntegerField err ("ENQ_RESP", m->err(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
926 CTFStringField err_desc ("ENQ_RESP_DESC", m->enqueueRejectionString());
927 CTFIntegerField verb ("VERBOSE", m->verb());
928 CTFIntegerField fmbpid ("FRM_BP_ID", m->fmbpid(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
929 CTFIntegerField fmsc ("FRM_STAT", m->fmsc(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
930 CTFIntegerField fmol ("FRM_OFFSET", m->fmol(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
931 CTFIntegerField fmfmt ("FRM_FMT", m->fmfmt(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
932 CTFIntegerField fmpid ("FRM_PRT_ID", m->fmpid(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
933 CTFIntegerField fmaddr ("FRM_ADDR", m->fmaddr(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
934
935 CTFFields fields;
936
937 fields.push_back(&tcode);
938 fields.push_back(&tcode_desc);
939 fields.push_back(&src_id);
940 fields.push_back(&src_id_desc);
941 fields.push_back(&timestamp);
942 fields.push_back(&ict_msg_type);
943 fields.push_back(&dpdm);
944 fields.push_back(&fqid);
945 fields.push_back(&cnum);
946 fields.push_back(&pnum);
947 fields.push_back(&ptype);
948 fields.push_back(&ptype_desc);
949 fields.push_back(&qet);
950 fields.push_back(&qet_desc);
951 fields.push_back(&orf);
952 fields.push_back(&erf);
953 fields.push_back(&err);
954 fields.push_back(&err_desc);
955 fields.push_back(&verb);
956 fields.push_back(&fmbpid);
957 fields.push_back(&fmsc);
958 fields.push_back(&fmol);
959 fields.push_back(&fmfmt);
960 fields.push_back(&fmpid);
961 fields.push_back(&fmaddr);
962
963 append_nexus_message(m, "Nexus DPQM In-Circuit Trace Message", fields);
964 useful_visit_ = true;
965 }
966
967 void CTFLogVisitor::visit(NxCoreInCircuitTraceMessage *m)
968 {
969 /* Default Nexus Message fields */
970 CTFIntegerField tcode ("TCODE", m->tcode());
971 CTFStringField tcode_desc ("TCODE_DESC", m->tcodeString());
972 CTFIntegerField src_id ("SRC_ID", m->sourceId());
973 CTFStringField src_id_desc ("SRC_ID_DESC", string(m->sourceIdString()));
974 CTFIntegerField timestamp ("TIMESTAMP", m->correctedTimestamp());
975
976 /* Nexus Core In-Circuit Trace fields */
977 CTFStringField ict_msg_type ("ICT_MSG_TYPE", string(m->ICTMessageType()));
978 CTFIntegerField cksrc ("CKSRC", m->cksrc());
979 CTFStringField cksrc_desc ("CKSRC_DESC", string(m->cksrcString()));
980 CTFIntegerField sync ("SYNC", m->sync());
981 CTFStringField sync_desc ("SYNC_DESC", string(m->syncString()));
982 CTFIntegerField ckdf ("CKDF", m->ckdf());
983 CTFIntegerField ckdata1 ("CKDATA1", m->ckdata1(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
984 CTFIntegerField ckdata2 ("CKDATA2", m->ckdata2(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
985
986 CTFFields fields;
987
988 fields.push_back(&tcode);
989 fields.push_back(&tcode_desc);
990 fields.push_back(&src_id);
991 fields.push_back(&src_id_desc);
992 fields.push_back(&timestamp);
993 fields.push_back(&ict_msg_type);
994 fields.push_back(&cksrc);
995 fields.push_back(&cksrc_desc);
996 fields.push_back(&sync);
997 fields.push_back(&sync_desc);
998 fields.push_back(&ckdf);
999 fields.push_back(&ckdata1);
1000 fields.push_back(&ckdata2);
1001
1002 append_nexus_message(m, "Nexus Core In-Circuit Trace Message", fields);
1003 useful_visit_ = true;
1004 }
1005
1006 void CTFLogVisitor::visit(NxInCircuitTraceMessage *m)
1007 {
1008 /* Default Nexus Message fields */
1009 CTFIntegerField tcode ("TCODE", m->tcode());
1010 CTFStringField tcode_desc ("TCODE_DESC", m->tcodeString());
1011 CTFIntegerField src_id ("SRC_ID", m->sourceId());
1012 CTFStringField src_id_desc ("SRC_ID_DESC", string(m->sourceIdString()));
1013 CTFIntegerField timestamp ("TIMESTAMP", m->correctedTimestamp());
1014
1015 /* Nexus In-Circuit Trace fields */
1016 CTFStringField ict_msg_type ("ICT_MSG_TYPE", string(m->ICTMessageType()));
1017
1018 CTFFields fields;
1019
1020 fields.push_back(&tcode);
1021 fields.push_back(&tcode_desc);
1022 fields.push_back(&src_id);
1023 fields.push_back(&src_id_desc);
1024 fields.push_back(&timestamp);
1025 fields.push_back(&ict_msg_type);
1026
1027 append_nexus_message(m, "Nexus In-Circuit Trace Message", fields);
1028 useful_visit_ = true;
1029 }
1030
1031 void CTFLogVisitor::visit(NxTimeStampCorrelation *m)
1032 {
1033 /* Default Nexus Message fields */
1034 CTFIntegerField tcode ("TCODE", m->tcode());
1035 CTFStringField tcode_desc ("TCODE_DESC", m->tcodeString());
1036 CTFIntegerField src_id ("SRC_ID", m->sourceId());
1037 CTFStringField src_id_desc ("SRC_ID_DESC", string(m->sourceIdString()));
1038 CTFIntegerField timestamp ("TIMESTAMP", m->correctedTimestamp());
1039
1040 /* Nexus Timestamp Correlation fields */
1041 CTFIntegerField tcorr ("TCORR", m->tcorr(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
1042 CTFIntegerField ttype ("TTYPE", m->ttype(), BT_CTF_INTEGER_BASE_HEXADECIMAL);
1043 CTFStringField ttype_desc ("TTYPE_DESC", string(m->ttypeString()));
1044
1045 CTFFields fields;
1046
1047 fields.push_back(&tcode);
1048 fields.push_back(&tcode_desc);
1049 fields.push_back(&src_id);
1050 fields.push_back(&src_id_desc);
1051 fields.push_back(&timestamp);
1052 fields.push_back(&tcorr);
1053 fields.push_back(&ttype);
1054 fields.push_back(&ttype_desc);
1055
1056 append_nexus_message(m, "Nexus Timestamp Correlation Message", fields);
1057 useful_visit_ = true;
1058 }
1059
1060 void CTFLogVisitor::visit(NxDPFMInCircuitTraceMessage *m)
1061 {
1062 /* Default Nexus Message fields */
1063 CTFIntegerField tcode ("TCODE", m->tcode());
1064 CTFStringField tcode_desc ("TCODE_DESC", m->tcodeString());
1065 CTFIntegerField src_id ("SRC_ID", m->sourceId());
1066 CTFStringField src_id_desc ("SRC_ID_DESC", string(m->sourceIdString()));
1067 CTFIntegerField timestamp ("TIMESTAMP", m->correctedTimestamp());
1068
1069 /* Nexus DPFM In-Circuit Trace fields */
1070 CTFStringField ict_msg_type ("ICT_MSG_TYPE", string(m->ICTMessageType()));
1071 CTFIntegerField fmsel ("FMAN_SEL", m->getFmsel());
1072 CTFIntegerField lbeat ("LAST_BEAT", m->getLbeat());
1073 CTFIntegerField btcnt ("BEAT_CNT", m->getBtcnt());
1074
1075 /* TODO: Handle context data as CTF array */
1076 /*CTFIntegerField context ("CONTEXT", m->tcode());*/
1077
1078 CTFFields fields;
1079
1080 fields.push_back(&tcode);
1081 fields.push_back(&tcode_desc);
1082 fields.push_back(&src_id);
1083 fields.push_back(&src_id_desc);
1084 fields.push_back(&timestamp);
1085 fields.push_back(&ict_msg_type);
1086 fields.push_back(&fmsel);
1087 fields.push_back(&lbeat);
1088 fields.push_back(&btcnt);
1089
1090 append_nexus_message(m, "Nexus DPFM In-Circuit Trace Message", fields);
1091 useful_visit_ = true;
1092 }
1093
1094 string CTFLogVisitor::asString() const
1095 {
1096 return "";
1097 }
BabelTrace - Trace Format Babel Tower
This page took 0.05705 seconds and 4 git commands to generate.