src/plugins/ctf/common/metadata/visitor-parent-links.cpp

   1 /*
   2  * SPDX-License-Identifier: MIT
   3  *
   4  * Copyright 2010 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   5  *
   6  * Common Trace Format Metadata Parent Link Creator.
   7  */
   8
   9 #include <errno.h>
  10
  11 #define BT_COMP_LOG_SELF_COMP (log_cfg->self_comp)
  12 #define BT_LOG_OUTPUT_LEVEL   (log_cfg->log_level)
  13 #define BT_LOG_TAG            "PLUGIN/CTF/META/PARENT-LINKS-VISITOR"
  14 #include "logging.hpp"
  15
  16 #include "common/list.h"
  17
  18 #include "ast.hpp"
  19
  20 static int ctf_visitor_unary_expression(int depth, struct ctf_node *node,
  21                                         struct meta_log_config *log_cfg)
  22 {
  23     int ret = 0;
  24
  25     switch (node->u.unary_expression.link) {
  26     case UNARY_LINK_UNKNOWN:
  27     case UNARY_DOTLINK:
  28     case UNARY_ARROWLINK:
  29     case UNARY_DOTDOTDOT:
  30         break;
  31     default:
  32         _BT_COMP_LOGE_APPEND_CAUSE_LINENO(node->lineno, "Unknown expression link type: type=%d\n",
  33                                           node->u.unary_expression.link);
  34         return -EINVAL;
  35     }
  36
  37     switch (node->u.unary_expression.type) {
  38     case UNARY_STRING:
  39     case UNARY_SIGNED_CONSTANT:
  40     case UNARY_UNSIGNED_CONSTANT:
  41         break;
  42     case UNARY_SBRAC:
  43         node->u.unary_expression.u.sbrac_exp->parent = node;
  44         ret =
  45             ctf_visitor_unary_expression(depth + 1, node->u.unary_expression.u.sbrac_exp, log_cfg);
  46         if (ret)
  47             return ret;
  48         break;
  49
  50     case UNARY_UNKNOWN:
  51     default:
  52         _BT_COMP_LOGE_APPEND_CAUSE_LINENO(node->lineno, "Unknown expression link type: type=%d\n",
  53                                           node->u.unary_expression.link);
  54         return -EINVAL;
  55     }
  56     return 0;
  57 }
  58
  59 static int ctf_visitor_type_specifier(int depth, struct ctf_node *node,
  60                                       struct meta_log_config *log_cfg)
  61 {
  62     int ret;
  63
  64     switch (node->u.field_class_specifier.type) {
  65     case TYPESPEC_VOID:
  66     case TYPESPEC_CHAR:
  67     case TYPESPEC_SHORT:
  68     case TYPESPEC_INT:
  69     case TYPESPEC_LONG:
  70     case TYPESPEC_FLOAT:
  71     case TYPESPEC_DOUBLE:
  72     case TYPESPEC_SIGNED:
  73     case TYPESPEC_UNSIGNED:
  74     case TYPESPEC_BOOL:
  75     case TYPESPEC_COMPLEX:
  76     case TYPESPEC_IMAGINARY:
  77     case TYPESPEC_CONST:
  78     case TYPESPEC_ID_TYPE:
  79         break;
  80     case TYPESPEC_FLOATING_POINT:
  81     case TYPESPEC_INTEGER:
  82     case TYPESPEC_STRING:
  83     case TYPESPEC_STRUCT:
  84     case TYPESPEC_VARIANT:
  85     case TYPESPEC_ENUM:
  86         node->u.field_class_specifier.node->parent = node;
  87         ret = ctf_visitor_parent_links(depth + 1, node->u.field_class_specifier.node, log_cfg);
  88         if (ret)
  89             return ret;
  90         break;
  91
  92     case TYPESPEC_UNKNOWN:
  93     default:
  94         _BT_COMP_LOGE_APPEND_CAUSE_LINENO(node->lineno, "Unknown type specifier: type=%d\n",
  95                                           node->u.field_class_specifier.type);
  96         return -EINVAL;
  97     }
  98     return 0;
  99 }
 100
 101 static int ctf_visitor_field_class_declarator(int depth, struct ctf_node *node,
 102                                               struct meta_log_config *log_cfg)
 103 {
 104     int ret = 0;
 105     struct ctf_node *iter;
 106
 107     depth++;
 108
 109     bt_list_for_each_entry (iter, &node->u.field_class_declarator.pointers, siblings) {
 110         iter->parent = node;
 111         ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
 112         if (ret)
 113             return ret;
 114     }
 115
 116     switch (node->u.field_class_declarator.type) {
 117     case TYPEDEC_ID:
 118         break;
 119     case TYPEDEC_NESTED:
 120         if (node->u.field_class_declarator.u.nested.field_class_declarator) {
 121             node->u.field_class_declarator.u.nested.field_class_declarator->parent = node;
 122             ret = ctf_visitor_parent_links(
 123                 depth + 1, node->u.field_class_declarator.u.nested.field_class_declarator, log_cfg);
 124             if (ret)
 125                 return ret;
 126         }
 127         if (!node->u.field_class_declarator.u.nested.abstract_array) {
 128             bt_list_for_each_entry (iter, &node->u.field_class_declarator.u.nested.length,
 129                                     siblings) {
 130                 iter->parent = node;
 131                 ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
 132                 if (ret)
 133                     return ret;
 134             }
 135         }
 136         if (node->u.field_class_declarator.bitfield_len) {
 137             node->u.field_class_declarator.bitfield_len = node;
 138             ret = ctf_visitor_parent_links(depth + 1, node->u.field_class_declarator.bitfield_len,
 139                                            log_cfg);
 140             if (ret)
 141                 return ret;
 142         }
 143         break;
 144     case TYPEDEC_UNKNOWN:
 145     default:
 146         _BT_COMP_LOGE_APPEND_CAUSE_LINENO(node->lineno, "Unknown type declarator: type=%d\n",
 147                                           node->u.field_class_declarator.type);
 148         return -EINVAL;
 149     }
 150     depth--;
 151     return 0;
 152 }
 153
 154 int ctf_visitor_parent_links(int depth, struct ctf_node *node, struct meta_log_config *log_cfg)
 155 {
 156     int ret = 0;
 157     struct ctf_node *iter;
 158
 159     if (node->visited)
 160         return 0;
 161
 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;
 166             ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
 167             if (ret)
 168                 return ret;
 169         }
 170         bt_list_for_each_entry (iter, &node->u.root.trace, siblings) {
 171             iter->parent = node;
 172             ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
 173             if (ret)
 174                 return ret;
 175         }
 176         bt_list_for_each_entry (iter, &node->u.root.stream, siblings) {
 177             iter->parent = node;
 178             ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
 179             if (ret)
 180                 return ret;
 181         }
 182         bt_list_for_each_entry (iter, &node->u.root.event, siblings) {
 183             iter->parent = node;
 184             ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
 185             if (ret)
 186                 return ret;
 187         }
 188         bt_list_for_each_entry (iter, &node->u.root.clock, siblings) {
 189             iter->parent = node;
 190             ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
 191             if (ret)
 192                 return ret;
 193         }
 194         bt_list_for_each_entry (iter, &node->u.root.callsite, siblings) {
 195             iter->parent = node;
 196             ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
 197             if (ret)
 198                 return ret;
 199         }
 200         break;
 201
 202     case NODE_EVENT:
 203         bt_list_for_each_entry (iter, &node->u.event.declaration_list, siblings) {
 204             iter->parent = node;
 205             ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
 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;
 213             ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
 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;
 221             ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
 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;
 229             ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
 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;
 237             ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
 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;
 245             ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
 246             if (ret)
 247                 return ret;
 248         }
 249         break;
 250
 251     case NODE_CTF_EXPRESSION:
 252         depth++;
 253         bt_list_for_each_entry (iter, &node->u.ctf_expression.left, siblings) {
 254             iter->parent = node;
 255             ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
 256             if (ret)
 257                 return ret;
 258         }
 259         bt_list_for_each_entry (iter, &node->u.ctf_expression.right, siblings) {
 260             iter->parent = node;
 261             ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
 262             if (ret)
 263                 return ret;
 264         }
 265         depth--;
 266         break;
 267     case NODE_UNARY_EXPRESSION:
 268         return ctf_visitor_unary_expression(depth, node, log_cfg);
 269
 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,
 274                                        node->u.field_class_def.field_class_specifier_list, log_cfg);
 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;
 279             ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
 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(
 289             depth + 1, node->u.field_class_alias_target.field_class_specifier_list, log_cfg);
 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;
 295             ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
 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(
 305             depth + 1, node->u.field_class_alias_name.field_class_specifier_list, log_cfg);
 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;
 311             ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
 312             if (ret)
 313                 return ret;
 314         }
 315         depth--;
 316         break;
 317     case NODE_TYPEALIAS:
 318         node->u.field_class_alias.target->parent = node;
 319         ret = ctf_visitor_parent_links(depth + 1, node->u.field_class_alias.target, log_cfg);
 320         if (ret)
 321             return ret;
 322         node->u.field_class_alias.alias->parent = node;
 323         ret = ctf_visitor_parent_links(depth + 1, node->u.field_class_alias.alias, log_cfg);
 324         if (ret)
 325             return ret;
 326         break;
 327
 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;
 331             ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
 332             if (ret)
 333                 return ret;
 334         }
 335         break;
 336
 337     case NODE_TYPE_SPECIFIER:
 338         ret = ctf_visitor_type_specifier(depth, node, log_cfg);
 339         if (ret)
 340             return ret;
 341         break;
 342     case NODE_POINTER:
 343         break;
 344     case NODE_TYPE_DECLARATOR:
 345         ret = ctf_visitor_field_class_declarator(depth, node, log_cfg);
 346         if (ret)
 347             return ret;
 348         break;
 349
 350     case NODE_FLOATING_POINT:
 351         bt_list_for_each_entry (iter, &node->u.floating_point.expressions, siblings) {
 352             iter->parent = node;
 353             ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
 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;
 361             ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
 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;
 369             ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
 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;
 377             ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
 378             if (ret)
 379                 return ret;
 380         }
 381         break;
 382     case NODE_ENUM:
 383         depth++;
 384         if (node->u._enum.container_field_class) {
 385             ret = ctf_visitor_parent_links(depth + 1, node->u._enum.container_field_class, log_cfg);
 386             if (ret)
 387                 return ret;
 388         }
 389
 390         bt_list_for_each_entry (iter, &node->u._enum.enumerator_list, siblings) {
 391             iter->parent = node;
 392             ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
 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(
 401             depth + 1, node->u.struct_or_variant_declaration.field_class_specifier_list, log_cfg);
 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;
 407             ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
 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;
 415             ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
 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;
 423             ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
 424             if (ret)
 425                 return ret;
 426         }
 427         bt_list_for_each_entry (iter, &node->u._struct.min_align, siblings) {
 428             iter->parent = node;
 429             ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
 430             if (ret)
 431                 return ret;
 432         }
 433         break;
 434
 435     case NODE_UNKNOWN:
 436     default:
 437         _BT_COMP_LOGE_APPEND_CAUSE_LINENO(node->lineno, "Unknown node type: type=%d\n", node->type);
 438         return -EINVAL;
 439     }
 440     return ret;
 441 }