Commit | Line | Data |
---|---|---|
e98a2d6e | 1 | /* |
0235b0db | 2 | * SPDX-License-Identifier: MIT |
e98a2d6e | 3 | * |
0235b0db | 4 | * Copyright 2010 Mathieu Desnoyers <mathieu.desnoyers@efficios.com> |
e98a2d6e | 5 | * |
0235b0db | 6 | * Common Trace Format Metadata Parent Link Creator. |
e98a2d6e PP |
7 | */ |
8 | ||
c802cacb | 9 | #include <errno.h> |
0f5c5d5c | 10 | #include <unistd.h> |
c802cacb | 11 | |
c802cacb | 12 | #include "logging.hpp" |
6fe1fe62 | 13 | |
578e048b | 14 | #include "common/list.h" |
c802cacb | 15 | |
087cd0f5 | 16 | #include "ast.hpp" |
e98a2d6e | 17 | |
4164020e | 18 | static int ctf_visitor_unary_expression(int depth, struct ctf_node *node, |
0f5c5d5c | 19 | const bt2c::Logger& logger) |
e98a2d6e | 20 | { |
4164020e | 21 | int ret = 0; |
e98a2d6e | 22 | |
4164020e SM |
23 | switch (node->u.unary_expression.link) { |
24 | case UNARY_LINK_UNKNOWN: | |
25 | case UNARY_DOTLINK: | |
26 | case UNARY_ARROWLINK: | |
27 | case UNARY_DOTDOTDOT: | |
28 | break; | |
29 | default: | |
0f5c5d5c SM |
30 | _BT_CPPLOGE_APPEND_CAUSE_LINENO(logger, node->lineno, |
31 | "Unknown expression link type: type={}\n", | |
32 | (int) node->u.unary_expression.link); | |
4164020e SM |
33 | return -EINVAL; |
34 | } | |
e98a2d6e | 35 | |
4164020e SM |
36 | switch (node->u.unary_expression.type) { |
37 | case UNARY_STRING: | |
38 | case UNARY_SIGNED_CONSTANT: | |
39 | case UNARY_UNSIGNED_CONSTANT: | |
40 | break; | |
41 | case UNARY_SBRAC: | |
42 | node->u.unary_expression.u.sbrac_exp->parent = node; | |
0f5c5d5c | 43 | ret = ctf_visitor_unary_expression(depth + 1, node->u.unary_expression.u.sbrac_exp, logger); |
4164020e SM |
44 | if (ret) |
45 | return ret; | |
46 | break; | |
e98a2d6e | 47 | |
4164020e SM |
48 | case UNARY_UNKNOWN: |
49 | default: | |
0f5c5d5c SM |
50 | _BT_CPPLOGE_APPEND_CAUSE_LINENO(logger, node->lineno, |
51 | "Unknown expression link type: type={}\n", | |
52 | (int) node->u.unary_expression.link); | |
4164020e SM |
53 | return -EINVAL; |
54 | } | |
55 | return 0; | |
e98a2d6e PP |
56 | } |
57 | ||
0f5c5d5c | 58 | static int ctf_visitor_type_specifier(int depth, struct ctf_node *node, const bt2c::Logger& logger) |
e98a2d6e | 59 | { |
4164020e | 60 | int ret; |
e98a2d6e | 61 | |
4164020e SM |
62 | switch (node->u.field_class_specifier.type) { |
63 | case TYPESPEC_VOID: | |
64 | case TYPESPEC_CHAR: | |
65 | case TYPESPEC_SHORT: | |
66 | case TYPESPEC_INT: | |
67 | case TYPESPEC_LONG: | |
68 | case TYPESPEC_FLOAT: | |
69 | case TYPESPEC_DOUBLE: | |
70 | case TYPESPEC_SIGNED: | |
71 | case TYPESPEC_UNSIGNED: | |
72 | case TYPESPEC_BOOL: | |
73 | case TYPESPEC_COMPLEX: | |
74 | case TYPESPEC_IMAGINARY: | |
75 | case TYPESPEC_CONST: | |
76 | case TYPESPEC_ID_TYPE: | |
77 | break; | |
78 | case TYPESPEC_FLOATING_POINT: | |
79 | case TYPESPEC_INTEGER: | |
80 | case TYPESPEC_STRING: | |
81 | case TYPESPEC_STRUCT: | |
82 | case TYPESPEC_VARIANT: | |
83 | case TYPESPEC_ENUM: | |
84 | node->u.field_class_specifier.node->parent = node; | |
0f5c5d5c | 85 | ret = ctf_visitor_parent_links(depth + 1, node->u.field_class_specifier.node, logger); |
4164020e SM |
86 | if (ret) |
87 | return ret; | |
88 | break; | |
e98a2d6e | 89 | |
4164020e SM |
90 | case TYPESPEC_UNKNOWN: |
91 | default: | |
0f5c5d5c SM |
92 | _BT_CPPLOGE_APPEND_CAUSE_LINENO(logger, node->lineno, "Unknown type specifier: type={}\n", |
93 | (int) node->u.field_class_specifier.type); | |
4164020e SM |
94 | return -EINVAL; |
95 | } | |
96 | return 0; | |
e98a2d6e PP |
97 | } |
98 | ||
4164020e | 99 | static int ctf_visitor_field_class_declarator(int depth, struct ctf_node *node, |
0f5c5d5c | 100 | const bt2c::Logger& logger) |
e98a2d6e | 101 | { |
4164020e SM |
102 | int ret = 0; |
103 | struct ctf_node *iter; | |
e98a2d6e | 104 | |
4164020e | 105 | depth++; |
e98a2d6e | 106 | |
4164020e SM |
107 | bt_list_for_each_entry (iter, &node->u.field_class_declarator.pointers, siblings) { |
108 | iter->parent = node; | |
0f5c5d5c | 109 | ret = ctf_visitor_parent_links(depth + 1, iter, logger); |
4164020e SM |
110 | if (ret) |
111 | return ret; | |
112 | } | |
e98a2d6e | 113 | |
4164020e SM |
114 | switch (node->u.field_class_declarator.type) { |
115 | case TYPEDEC_ID: | |
116 | break; | |
117 | case TYPEDEC_NESTED: | |
118 | if (node->u.field_class_declarator.u.nested.field_class_declarator) { | |
119 | node->u.field_class_declarator.u.nested.field_class_declarator->parent = node; | |
120 | ret = ctf_visitor_parent_links( | |
0f5c5d5c | 121 | depth + 1, node->u.field_class_declarator.u.nested.field_class_declarator, logger); |
4164020e SM |
122 | if (ret) |
123 | return ret; | |
124 | } | |
125 | if (!node->u.field_class_declarator.u.nested.abstract_array) { | |
126 | bt_list_for_each_entry (iter, &node->u.field_class_declarator.u.nested.length, | |
127 | siblings) { | |
128 | iter->parent = node; | |
0f5c5d5c | 129 | ret = ctf_visitor_parent_links(depth + 1, iter, logger); |
4164020e SM |
130 | if (ret) |
131 | return ret; | |
132 | } | |
133 | } | |
134 | if (node->u.field_class_declarator.bitfield_len) { | |
135 | node->u.field_class_declarator.bitfield_len = node; | |
136 | ret = ctf_visitor_parent_links(depth + 1, node->u.field_class_declarator.bitfield_len, | |
0f5c5d5c | 137 | logger); |
4164020e SM |
138 | if (ret) |
139 | return ret; | |
140 | } | |
141 | break; | |
142 | case TYPEDEC_UNKNOWN: | |
143 | default: | |
0f5c5d5c SM |
144 | _BT_CPPLOGE_APPEND_CAUSE_LINENO(logger, node->lineno, "Unknown type declarator: type={}\n", |
145 | (int) node->u.field_class_declarator.type); | |
4164020e SM |
146 | return -EINVAL; |
147 | } | |
148 | depth--; | |
149 | return 0; | |
e98a2d6e PP |
150 | } |
151 | ||
0f5c5d5c | 152 | int ctf_visitor_parent_links(int depth, struct ctf_node *node, const bt2c::Logger& parentLogger) |
e98a2d6e | 153 | { |
4164020e SM |
154 | int ret = 0; |
155 | struct ctf_node *iter; | |
e98a2d6e | 156 | |
4164020e SM |
157 | if (node->visited) |
158 | return 0; | |
e98a2d6e | 159 | |
0f5c5d5c SM |
160 | bt2c::Logger logger {parentLogger, "PLUGIN/CTF/META/PARENT-LINKS-VISITOR"}; |
161 | ||
4164020e SM |
162 | switch (node->type) { |
163 | case NODE_ROOT: | |
164 | bt_list_for_each_entry (iter, &node->u.root.declaration_list, siblings) { | |
165 | iter->parent = node; | |
0f5c5d5c | 166 | ret = ctf_visitor_parent_links(depth + 1, iter, logger); |
4164020e SM |
167 | if (ret) |
168 | return ret; | |
169 | } | |
170 | bt_list_for_each_entry (iter, &node->u.root.trace, siblings) { | |
171 | iter->parent = node; | |
0f5c5d5c | 172 | ret = ctf_visitor_parent_links(depth + 1, iter, logger); |
4164020e SM |
173 | if (ret) |
174 | return ret; | |
175 | } | |
176 | bt_list_for_each_entry (iter, &node->u.root.stream, siblings) { | |
177 | iter->parent = node; | |
0f5c5d5c | 178 | ret = ctf_visitor_parent_links(depth + 1, iter, logger); |
4164020e SM |
179 | if (ret) |
180 | return ret; | |
181 | } | |
182 | bt_list_for_each_entry (iter, &node->u.root.event, siblings) { | |
183 | iter->parent = node; | |
0f5c5d5c | 184 | ret = ctf_visitor_parent_links(depth + 1, iter, logger); |
4164020e SM |
185 | if (ret) |
186 | return ret; | |
187 | } | |
188 | bt_list_for_each_entry (iter, &node->u.root.clock, siblings) { | |
189 | iter->parent = node; | |
0f5c5d5c | 190 | ret = ctf_visitor_parent_links(depth + 1, iter, logger); |
4164020e SM |
191 | if (ret) |
192 | return ret; | |
193 | } | |
194 | bt_list_for_each_entry (iter, &node->u.root.callsite, siblings) { | |
195 | iter->parent = node; | |
0f5c5d5c | 196 | ret = ctf_visitor_parent_links(depth + 1, iter, logger); |
4164020e SM |
197 | if (ret) |
198 | return ret; | |
199 | } | |
200 | break; | |
e98a2d6e | 201 | |
4164020e SM |
202 | case NODE_EVENT: |
203 | bt_list_for_each_entry (iter, &node->u.event.declaration_list, siblings) { | |
204 | iter->parent = node; | |
0f5c5d5c | 205 | ret = ctf_visitor_parent_links(depth + 1, iter, logger); |
4164020e SM |
206 | if (ret) |
207 | return ret; | |
208 | } | |
209 | break; | |
210 | case NODE_STREAM: | |
211 | bt_list_for_each_entry (iter, &node->u.stream.declaration_list, siblings) { | |
212 | iter->parent = node; | |
0f5c5d5c | 213 | ret = ctf_visitor_parent_links(depth + 1, iter, logger); |
4164020e SM |
214 | if (ret) |
215 | return ret; | |
216 | } | |
217 | break; | |
218 | case NODE_ENV: | |
219 | bt_list_for_each_entry (iter, &node->u.env.declaration_list, siblings) { | |
220 | iter->parent = node; | |
0f5c5d5c | 221 | ret = ctf_visitor_parent_links(depth + 1, iter, logger); |
4164020e SM |
222 | if (ret) |
223 | return ret; | |
224 | } | |
225 | break; | |
226 | case NODE_TRACE: | |
227 | bt_list_for_each_entry (iter, &node->u.trace.declaration_list, siblings) { | |
228 | iter->parent = node; | |
0f5c5d5c | 229 | ret = ctf_visitor_parent_links(depth + 1, iter, logger); |
4164020e SM |
230 | if (ret) |
231 | return ret; | |
232 | } | |
233 | break; | |
234 | case NODE_CLOCK: | |
235 | bt_list_for_each_entry (iter, &node->u.clock.declaration_list, siblings) { | |
236 | iter->parent = node; | |
0f5c5d5c | 237 | ret = ctf_visitor_parent_links(depth + 1, iter, logger); |
4164020e SM |
238 | if (ret) |
239 | return ret; | |
240 | } | |
241 | break; | |
242 | case NODE_CALLSITE: | |
243 | bt_list_for_each_entry (iter, &node->u.callsite.declaration_list, siblings) { | |
244 | iter->parent = node; | |
0f5c5d5c | 245 | ret = ctf_visitor_parent_links(depth + 1, iter, logger); |
4164020e SM |
246 | if (ret) |
247 | return ret; | |
248 | } | |
249 | break; | |
e98a2d6e | 250 | |
4164020e SM |
251 | case NODE_CTF_EXPRESSION: |
252 | depth++; | |
253 | bt_list_for_each_entry (iter, &node->u.ctf_expression.left, siblings) { | |
254 | iter->parent = node; | |
0f5c5d5c | 255 | ret = ctf_visitor_parent_links(depth + 1, iter, logger); |
4164020e SM |
256 | if (ret) |
257 | return ret; | |
258 | } | |
259 | bt_list_for_each_entry (iter, &node->u.ctf_expression.right, siblings) { | |
260 | iter->parent = node; | |
0f5c5d5c | 261 | ret = ctf_visitor_parent_links(depth + 1, iter, logger); |
4164020e SM |
262 | if (ret) |
263 | return ret; | |
264 | } | |
265 | depth--; | |
266 | break; | |
267 | case NODE_UNARY_EXPRESSION: | |
0f5c5d5c | 268 | return ctf_visitor_unary_expression(depth, node, logger); |
e98a2d6e | 269 | |
4164020e SM |
270 | case NODE_TYPEDEF: |
271 | depth++; | |
272 | node->u.field_class_def.field_class_specifier_list->parent = node; | |
273 | ret = ctf_visitor_parent_links(depth + 1, | |
0f5c5d5c | 274 | node->u.field_class_def.field_class_specifier_list, logger); |
4164020e SM |
275 | if (ret) |
276 | return ret; | |
277 | bt_list_for_each_entry (iter, &node->u.field_class_def.field_class_declarators, siblings) { | |
278 | iter->parent = node; | |
0f5c5d5c | 279 | ret = ctf_visitor_parent_links(depth + 1, iter, logger); |
4164020e SM |
280 | if (ret) |
281 | return ret; | |
282 | } | |
283 | depth--; | |
284 | break; | |
285 | case NODE_TYPEALIAS_TARGET: | |
286 | depth++; | |
287 | node->u.field_class_alias_target.field_class_specifier_list->parent = node; | |
288 | ret = ctf_visitor_parent_links( | |
0f5c5d5c | 289 | depth + 1, node->u.field_class_alias_target.field_class_specifier_list, logger); |
4164020e SM |
290 | if (ret) |
291 | return ret; | |
292 | bt_list_for_each_entry (iter, &node->u.field_class_alias_target.field_class_declarators, | |
293 | siblings) { | |
294 | iter->parent = node; | |
0f5c5d5c | 295 | ret = ctf_visitor_parent_links(depth + 1, iter, logger); |
4164020e SM |
296 | if (ret) |
297 | return ret; | |
298 | } | |
299 | depth--; | |
300 | break; | |
301 | case NODE_TYPEALIAS_ALIAS: | |
302 | depth++; | |
303 | node->u.field_class_alias_name.field_class_specifier_list->parent = node; | |
304 | ret = ctf_visitor_parent_links( | |
0f5c5d5c | 305 | depth + 1, node->u.field_class_alias_name.field_class_specifier_list, logger); |
4164020e SM |
306 | if (ret) |
307 | return ret; | |
308 | bt_list_for_each_entry (iter, &node->u.field_class_alias_name.field_class_declarators, | |
309 | siblings) { | |
310 | iter->parent = node; | |
0f5c5d5c | 311 | ret = ctf_visitor_parent_links(depth + 1, iter, logger); |
4164020e SM |
312 | if (ret) |
313 | return ret; | |
314 | } | |
315 | depth--; | |
316 | break; | |
317 | case NODE_TYPEALIAS: | |
318 | node->u.field_class_alias.target->parent = node; | |
0f5c5d5c | 319 | ret = ctf_visitor_parent_links(depth + 1, node->u.field_class_alias.target, logger); |
4164020e SM |
320 | if (ret) |
321 | return ret; | |
322 | node->u.field_class_alias.alias->parent = node; | |
0f5c5d5c | 323 | ret = ctf_visitor_parent_links(depth + 1, node->u.field_class_alias.alias, logger); |
4164020e SM |
324 | if (ret) |
325 | return ret; | |
326 | break; | |
e98a2d6e | 327 | |
4164020e SM |
328 | case NODE_TYPE_SPECIFIER_LIST: |
329 | bt_list_for_each_entry (iter, &node->u.field_class_specifier_list.head, siblings) { | |
330 | iter->parent = node; | |
0f5c5d5c | 331 | ret = ctf_visitor_parent_links(depth + 1, iter, logger); |
4164020e SM |
332 | if (ret) |
333 | return ret; | |
334 | } | |
335 | break; | |
e98a2d6e | 336 | |
4164020e | 337 | case NODE_TYPE_SPECIFIER: |
0f5c5d5c | 338 | ret = ctf_visitor_type_specifier(depth, node, logger); |
4164020e SM |
339 | if (ret) |
340 | return ret; | |
341 | break; | |
342 | case NODE_POINTER: | |
343 | break; | |
344 | case NODE_TYPE_DECLARATOR: | |
0f5c5d5c | 345 | ret = ctf_visitor_field_class_declarator(depth, node, logger); |
4164020e SM |
346 | if (ret) |
347 | return ret; | |
348 | break; | |
e98a2d6e | 349 | |
4164020e SM |
350 | case NODE_FLOATING_POINT: |
351 | bt_list_for_each_entry (iter, &node->u.floating_point.expressions, siblings) { | |
352 | iter->parent = node; | |
0f5c5d5c | 353 | ret = ctf_visitor_parent_links(depth + 1, iter, logger); |
4164020e SM |
354 | if (ret) |
355 | return ret; | |
356 | } | |
357 | break; | |
358 | case NODE_INTEGER: | |
359 | bt_list_for_each_entry (iter, &node->u.integer.expressions, siblings) { | |
360 | iter->parent = node; | |
0f5c5d5c | 361 | ret = ctf_visitor_parent_links(depth + 1, iter, logger); |
4164020e SM |
362 | if (ret) |
363 | return ret; | |
364 | } | |
365 | break; | |
366 | case NODE_STRING: | |
367 | bt_list_for_each_entry (iter, &node->u.string.expressions, siblings) { | |
368 | iter->parent = node; | |
0f5c5d5c | 369 | ret = ctf_visitor_parent_links(depth + 1, iter, logger); |
4164020e SM |
370 | if (ret) |
371 | return ret; | |
372 | } | |
373 | break; | |
374 | case NODE_ENUMERATOR: | |
375 | bt_list_for_each_entry (iter, &node->u.enumerator.values, siblings) { | |
376 | iter->parent = node; | |
0f5c5d5c | 377 | ret = ctf_visitor_parent_links(depth + 1, iter, logger); |
4164020e SM |
378 | if (ret) |
379 | return ret; | |
380 | } | |
381 | break; | |
382 | case NODE_ENUM: | |
383 | depth++; | |
384 | if (node->u._enum.container_field_class) { | |
0f5c5d5c | 385 | ret = ctf_visitor_parent_links(depth + 1, node->u._enum.container_field_class, logger); |
4164020e SM |
386 | if (ret) |
387 | return ret; | |
388 | } | |
e98a2d6e | 389 | |
4164020e SM |
390 | bt_list_for_each_entry (iter, &node->u._enum.enumerator_list, siblings) { |
391 | iter->parent = node; | |
0f5c5d5c | 392 | ret = ctf_visitor_parent_links(depth + 1, iter, logger); |
4164020e SM |
393 | if (ret) |
394 | return ret; | |
395 | } | |
396 | depth--; | |
397 | break; | |
398 | case NODE_STRUCT_OR_VARIANT_DECLARATION: | |
399 | node->u.struct_or_variant_declaration.field_class_specifier_list->parent = node; | |
400 | ret = ctf_visitor_parent_links( | |
0f5c5d5c | 401 | depth + 1, node->u.struct_or_variant_declaration.field_class_specifier_list, logger); |
4164020e SM |
402 | if (ret) |
403 | return ret; | |
404 | bt_list_for_each_entry ( | |
405 | iter, &node->u.struct_or_variant_declaration.field_class_declarators, siblings) { | |
406 | iter->parent = node; | |
0f5c5d5c | 407 | ret = ctf_visitor_parent_links(depth + 1, iter, logger); |
4164020e SM |
408 | if (ret) |
409 | return ret; | |
410 | } | |
411 | break; | |
412 | case NODE_VARIANT: | |
413 | bt_list_for_each_entry (iter, &node->u.variant.declaration_list, siblings) { | |
414 | iter->parent = node; | |
0f5c5d5c | 415 | ret = ctf_visitor_parent_links(depth + 1, iter, logger); |
4164020e SM |
416 | if (ret) |
417 | return ret; | |
418 | } | |
419 | break; | |
420 | case NODE_STRUCT: | |
421 | bt_list_for_each_entry (iter, &node->u._struct.declaration_list, siblings) { | |
422 | iter->parent = node; | |
0f5c5d5c | 423 | ret = ctf_visitor_parent_links(depth + 1, iter, logger); |
4164020e SM |
424 | if (ret) |
425 | return ret; | |
426 | } | |
427 | bt_list_for_each_entry (iter, &node->u._struct.min_align, siblings) { | |
428 | iter->parent = node; | |
0f5c5d5c | 429 | ret = ctf_visitor_parent_links(depth + 1, iter, logger); |
4164020e SM |
430 | if (ret) |
431 | return ret; | |
432 | } | |
433 | break; | |
e98a2d6e | 434 | |
4164020e SM |
435 | case NODE_UNKNOWN: |
436 | default: | |
0f5c5d5c SM |
437 | _BT_CPPLOGE_APPEND_CAUSE_LINENO(logger, node->lineno, "Unknown node type: type={}\n", |
438 | (int) node->type); | |
4164020e SM |
439 | return -EINVAL; |
440 | } | |
441 | return ret; | |
e98a2d6e | 442 | } |