X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=src%2Fplugins%2Fctf%2Fcommon%2Fmetadata%2Fvisitor-generate-ir.c;h=3413ac17cd679b7f162d75eac1b4b941b7f9e244;hb=45c51519900e100d9acda4acb9516ef69bc2d045;hp=2b87f609b421da3fbd046966a11b289bb734fe25;hpb=350ad6c1c5f45a4e90c33e3c1354125c209bbf02;p=babeltrace.git

diff --git a/src/plugins/ctf/common/metadata/visitor-generate-ir.c b/src/plugins/ctf/common/metadata/visitor-generate-ir.c
index 2b87f609..3413ac17 100644
--- a/src/plugins/ctf/common/metadata/visitor-generate-ir.c
+++ b/src/plugins/ctf/common/metadata/visitor-generate-ir.c
@@ -27,8 +27,10 @@
  * SOFTWARE.
  */
 
+#define BT_COMP_LOG_SELF_COMP (ctx->log_cfg.self_comp)
+#define BT_LOG_OUTPUT_LEVEL (ctx->log_cfg.log_level)
 #define BT_LOG_TAG "PLUGIN/CTF/META/IR-VISITOR"
-#include "logging.h"
+#include "plugins/comp-logging.h"
 
 #include <stdio.h>
 #include <unistd.h>
@@ -41,10 +43,11 @@
 #include <inttypes.h>
 #include <errno.h>
 #include "common/common.h"
-#include "compat/uuid.h"
+#include "common/uuid.h"
 #include "compat/endian.h"
 #include <babeltrace2/babeltrace.h>
 
+#include "logging.h"
 #include "scanner.h"
 #include "parser.h"
 #include "ast.h"
@@ -66,7 +69,7 @@
 	do {								\
 		ret = ctx_push_scope(ctx);				\
 		if (ret) {						\
-			BT_LOGE_STR("Cannot push scope.");		\
+			BT_COMP_LOGE_STR("Cannot push scope.");		\
 			goto error;					\
 		}							\
 	} while (0)
@@ -158,19 +161,19 @@ enum loglevel {
 #define _BT_LIST_FIRST_ENTRY(_ptr, _class, _member)			\
 	bt_list_entry((_ptr)->next, _class, _member)
 
-#define _BT_LOGE_DUP_ATTR(_node, _attr, _entity)			\
-	_BT_LOGE_LINENO((_node)->lineno,				\
+#define _BT_COMP_LOGE_DUP_ATTR(_node, _attr, _entity)			\
+	_BT_COMP_LOGE_LINENO((_node)->lineno,				\
 		"Duplicate attribute in %s: attr-name=\"%s\"",		\
 		_entity, _attr)
 
-#define _BT_LOGE_NODE(_node, _msg, args...)				\
-	_BT_LOGE_LINENO((_node)->lineno, _msg, ## args)
+#define _BT_COMP_LOGE_NODE(_node, _msg, args...)				\
+	_BT_COMP_LOGE_LINENO((_node)->lineno, _msg, ## args)
 
-#define _BT_LOGW_NODE(_node, _msg, args...)				\
-	_BT_LOGW_LINENO((_node)->lineno, _msg, ## args)
+#define _BT_COMP_LOGW_NODE(_node, _msg, args...)				\
+	_BT_COMP_LOGW_LINENO((_node)->lineno, _msg, ## args)
 
-#define _BT_LOGV_NODE(_node, _msg, args...)				\
-	_BT_LOGV_LINENO((_node)->lineno, _msg, ## args)
+#define _BT_COMP_LOGT_NODE(_node, _msg, args...)				\
+	_BT_COMP_LOGT_LINENO((_node)->lineno, _msg, ## args)
 
 /*
  * Declaration scope of a visitor context. This represents a TSDL
@@ -193,7 +196,8 @@ struct ctx_decl_scope {
  * Visitor context (private).
  */
 struct ctx {
-	bt_self_component_source *self_comp;
+	struct meta_log_config log_cfg;
+
 	/* Trace IR trace class being filled (owned by this) */
 	bt_trace_class *trace_class;
 
@@ -225,13 +229,14 @@ struct ctf_visitor_generate_ir;
  * @returns		New declaration scope, or NULL on error
  */
 static
-struct ctx_decl_scope *ctx_decl_scope_create(struct ctx_decl_scope *par_scope)
+struct ctx_decl_scope *ctx_decl_scope_create(struct ctx *ctx,
+		struct ctx_decl_scope *par_scope)
 {
 	struct ctx_decl_scope *scope;
 
 	scope = g_new(struct ctx_decl_scope, 1);
 	if (!scope) {
-		BT_LOGE_STR("Failed to allocate one declaration scope.");
+		BT_COMP_LOGE_STR("Failed to allocate one declaration scope.");
 		goto end;
 	}
 
@@ -272,7 +277,7 @@ end:
  * @returns		Associated GQuark, or 0 on error
  */
 static
-GQuark get_prefixed_named_quark(char prefix, const char *name)
+GQuark get_prefixed_named_quark(struct ctx *ctx, char prefix, const char *name)
 {
 	GQuark qname = 0;
 
@@ -281,7 +286,7 @@ GQuark get_prefixed_named_quark(char prefix, const char *name)
 	/* Prefix character + original string + '\0' */
 	char *prname = g_new(char, strlen(name) + 2);
 	if (!prname) {
-		BT_LOGE_STR("Failed to allocate a string.");
+		BT_COMP_LOGE_STR("Failed to allocate a string.");
 		goto end;
 	}
 
@@ -306,8 +311,8 @@ end:
  */
 static
 struct ctf_field_class *ctx_decl_scope_lookup_prefix_alias(
-		struct ctx_decl_scope *scope, char prefix, const char *name,
-		int levels, bool copy)
+		struct ctx *ctx, struct ctx_decl_scope *scope, char prefix,
+		const char *name, int levels, bool copy)
 {
 	GQuark qname = 0;
 	int cur_levels = 0;
@@ -316,7 +321,7 @@ struct ctf_field_class *ctx_decl_scope_lookup_prefix_alias(
 
 	BT_ASSERT(scope);
 	BT_ASSERT(name);
-	qname = get_prefixed_named_quark(prefix, name);
+	qname = get_prefixed_named_quark(ctx, prefix, name);
 	if (!qname) {
 		goto end;
 	}
@@ -357,11 +362,11 @@ end:
  *			or NULL if not found
  */
 static
-struct ctf_field_class *ctx_decl_scope_lookup_alias(
+struct ctf_field_class *ctx_decl_scope_lookup_alias(struct ctx *ctx,
 		struct ctx_decl_scope *scope, const char *name, int levels,
 		bool copy)
 {
-	return ctx_decl_scope_lookup_prefix_alias(scope, _PREFIX_ALIAS,
+	return ctx_decl_scope_lookup_prefix_alias(ctx, scope, _PREFIX_ALIAS,
 		name, levels, copy);
 }
 
@@ -376,12 +381,12 @@ struct ctf_field_class *ctx_decl_scope_lookup_alias(
  *			or NULL if not found
  */
 static
-struct ctf_field_class_enum *ctx_decl_scope_lookup_enum(
+struct ctf_field_class_enum *ctx_decl_scope_lookup_enum(struct ctx *ctx,
 		struct ctx_decl_scope *scope, const char *name, int levels,
 		bool copy)
 {
-	return (void *) ctx_decl_scope_lookup_prefix_alias(scope, _PREFIX_ENUM,
-		name, levels, copy);
+	return (void *) ctx_decl_scope_lookup_prefix_alias(ctx, scope,
+		_PREFIX_ENUM, name, levels, copy);
 }
 
 /**
@@ -395,11 +400,11 @@ struct ctf_field_class_enum *ctx_decl_scope_lookup_enum(
  *			or NULL if not found
  */
 static
-struct ctf_field_class_struct *ctx_decl_scope_lookup_struct(
+struct ctf_field_class_struct *ctx_decl_scope_lookup_struct(struct ctx *ctx,
 		struct ctx_decl_scope *scope, const char *name, int levels,
 		bool copy)
 {
-	return (void *) ctx_decl_scope_lookup_prefix_alias(scope,
+	return (void *) ctx_decl_scope_lookup_prefix_alias(ctx, scope,
 		_PREFIX_STRUCT, name, levels, copy);
 }
 
@@ -414,11 +419,11 @@ struct ctf_field_class_struct *ctx_decl_scope_lookup_struct(
  *			or NULL if not found
  */
 static
-struct ctf_field_class_variant *ctx_decl_scope_lookup_variant(
+struct ctf_field_class_variant *ctx_decl_scope_lookup_variant(struct ctx *ctx,
 		struct ctx_decl_scope *scope, const char *name, int levels,
 		bool copy)
 {
-	return (void *) ctx_decl_scope_lookup_prefix_alias(scope,
+	return (void *) ctx_decl_scope_lookup_prefix_alias(ctx, scope,
 		_PREFIX_VARIANT, name, levels, copy);
 }
 
@@ -432,8 +437,9 @@ struct ctf_field_class_variant *ctx_decl_scope_lookup_variant(
  * @returns		0 if registration went okay, negative value otherwise
  */
 static
-int ctx_decl_scope_register_prefix_alias(struct ctx_decl_scope *scope,
-		char prefix, const char *name, struct ctf_field_class *decl)
+int ctx_decl_scope_register_prefix_alias(struct ctx *ctx,
+		struct ctx_decl_scope *scope, char prefix, const char *name,
+		struct ctf_field_class *decl)
 {
 	int ret = 0;
 	GQuark qname = 0;
@@ -441,14 +447,14 @@ int ctx_decl_scope_register_prefix_alias(struct ctx_decl_scope *scope,
 	BT_ASSERT(scope);
 	BT_ASSERT(name);
 	BT_ASSERT(decl);
-	qname = get_prefixed_named_quark(prefix, name);
+	qname = get_prefixed_named_quark(ctx, prefix, name);
 	if (!qname) {
 		ret = -ENOMEM;
 		goto end;
 	}
 
 	/* Make sure alias does not exist in local scope */
-	if (ctx_decl_scope_lookup_prefix_alias(scope, prefix, name, 1,
+	if (ctx_decl_scope_lookup_prefix_alias(ctx, scope, prefix, name, 1,
 			false)) {
 		ret = -EEXIST;
 		goto end;
@@ -471,10 +477,10 @@ end:
  * @returns	0 if registration went okay, negative value otherwise
  */
 static
-int ctx_decl_scope_register_alias(struct ctx_decl_scope *scope,
+int ctx_decl_scope_register_alias(struct ctx *ctx, struct ctx_decl_scope *scope,
 		const char *name, struct ctf_field_class *decl)
 {
-	return ctx_decl_scope_register_prefix_alias(scope, _PREFIX_ALIAS,
+	return ctx_decl_scope_register_prefix_alias(ctx, scope, _PREFIX_ALIAS,
 		name, (void *) decl);
 }
 
@@ -487,10 +493,10 @@ int ctx_decl_scope_register_alias(struct ctx_decl_scope *scope,
  * @returns	0 if registration went okay, negative value otherwise
  */
 static
-int ctx_decl_scope_register_enum(struct ctx_decl_scope *scope,
+int ctx_decl_scope_register_enum(struct ctx *ctx, struct ctx_decl_scope *scope,
 		const char *name, struct ctf_field_class_enum *decl)
 {
-	return ctx_decl_scope_register_prefix_alias(scope, _PREFIX_ENUM,
+	return ctx_decl_scope_register_prefix_alias(ctx, scope, _PREFIX_ENUM,
 		name, (void *) decl);
 }
 
@@ -503,10 +509,11 @@ int ctx_decl_scope_register_enum(struct ctx_decl_scope *scope,
  * @returns	0 if registration went okay, negative value otherwise
  */
 static
-int ctx_decl_scope_register_struct(struct ctx_decl_scope *scope,
-		const char *name, struct ctf_field_class_struct *decl)
+int ctx_decl_scope_register_struct(struct ctx *ctx,
+		struct ctx_decl_scope *scope, const char *name,
+		struct ctf_field_class_struct *decl)
 {
-	return ctx_decl_scope_register_prefix_alias(scope, _PREFIX_STRUCT,
+	return ctx_decl_scope_register_prefix_alias(ctx, scope, _PREFIX_STRUCT,
 		name, (void *) decl);
 }
 
@@ -519,10 +526,11 @@ int ctx_decl_scope_register_struct(struct ctx_decl_scope *scope,
  * @returns	0 if registration went okay, negative value otherwise
  */
 static
-int ctx_decl_scope_register_variant(struct ctx_decl_scope *scope,
-		const char *name, struct ctf_field_class_variant *decl)
+int ctx_decl_scope_register_variant(struct ctx *ctx,
+		struct ctx_decl_scope *scope, const char *name,
+		struct ctf_field_class_variant *decl)
 {
-	return ctx_decl_scope_register_prefix_alias(scope, _PREFIX_VARIANT,
+	return ctx_decl_scope_register_prefix_alias(ctx, scope, _PREFIX_VARIANT,
 		name, (void *) decl);
 }
 
@@ -571,8 +579,7 @@ end:
  * @returns	New visitor context, or NULL on error
  */
 static
-struct ctx *ctx_create(bt_self_component_source *self_comp,
-		const struct ctf_metadata_decoder_config *decoder_config)
+struct ctx *ctx_create(const struct ctf_metadata_decoder_config *decoder_config)
 {
 	struct ctx *ctx = NULL;
 
@@ -580,30 +587,34 @@ struct ctx *ctx_create(bt_self_component_source *self_comp,
 
 	ctx = g_new0(struct ctx, 1);
 	if (!ctx) {
-		BT_LOGE_STR("Failed to allocate one visitor context.");
+		BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, decoder_config->log_level,
+			decoder_config->self_comp,
+			"Failed to allocate one visitor context.");
 		goto error;
 	}
 
-	if (self_comp) {
+	ctx->log_cfg.log_level = decoder_config->log_level;
+	ctx->log_cfg.self_comp = decoder_config->self_comp;
+
+	if (decoder_config->self_comp) {
 		ctx->trace_class = bt_trace_class_create(
-			bt_self_component_source_as_self_component(self_comp));
+			decoder_config->self_comp);
 		if (!ctx->trace_class) {
-			BT_LOGE_STR("Cannot create empty trace class.");
+			BT_COMP_LOGE_STR("Cannot create empty trace class.");
 			goto error;
 		}
-		ctx->self_comp = self_comp;
 	}
 
 	ctx->ctf_tc = ctf_trace_class_create();
 	if (!ctx->ctf_tc) {
-		BT_LOGE_STR("Cannot create CTF trace class.");
+		BT_COMP_LOGE_STR("Cannot create CTF trace class.");
 		goto error;
 	}
 
 	/* Root declaration scope */
-	ctx->current_scope = ctx_decl_scope_create(NULL);
+	ctx->current_scope = ctx_decl_scope_create(ctx, NULL);
 	if (!ctx->current_scope) {
-		BT_LOGE_STR("Cannot create declaration scope.");
+		BT_COMP_LOGE_STR("Cannot create declaration scope.");
 		goto error;
 	}
 
@@ -632,9 +643,9 @@ int ctx_push_scope(struct ctx *ctx)
 	struct ctx_decl_scope *new_scope;
 
 	BT_ASSERT(ctx);
-	new_scope = ctx_decl_scope_create(ctx->current_scope);
+	new_scope = ctx_decl_scope_create(ctx, ctx->current_scope);
 	if (!new_scope) {
-		BT_LOGE_STR("Cannot create declaration scope.");
+		BT_COMP_LOGE_STR("Cannot create declaration scope.");
 		ret = -ENOMEM;
 		goto end;
 	}
@@ -668,61 +679,6 @@ static
 int visit_field_class_specifier_list(struct ctx *ctx, struct ctf_node *ts_list,
 		struct ctf_field_class **decl);
 
-static
-char *remove_underscores_from_field_ref(const char *field_ref)
-{
-	const char *in_ch;
-	char *out_ch;
-	char *ret;
-	enum {
-		UNDERSCORE_REMOVE_STATE_REMOVE_NEXT_UNDERSCORE,
-		UNDERSCORE_REMOVE_STATE_DO_NOT_REMOVE_NEXT_UNDERSCORE,
-	} state = UNDERSCORE_REMOVE_STATE_REMOVE_NEXT_UNDERSCORE;
-
-	BT_ASSERT(field_ref);
-	ret = calloc(strlen(field_ref) + 1, 1);
-	if (!ret) {
-		BT_LOGE("Failed to allocate a string: size=%zu",
-			strlen(field_ref) + 1);
-		goto end;
-	}
-
-	in_ch = field_ref;
-	out_ch = ret;
-
-	while (*in_ch != '\0') {
-		switch (*in_ch) {
-		case ' ':
-		case '\t':
-			/* Remove whitespace */
-			in_ch++;
-			continue;
-		case '_':
-			if (state == UNDERSCORE_REMOVE_STATE_REMOVE_NEXT_UNDERSCORE) {
-				in_ch++;
-				state = UNDERSCORE_REMOVE_STATE_DO_NOT_REMOVE_NEXT_UNDERSCORE;
-				continue;
-			}
-
-			goto copy;
-		case '.':
-			state = UNDERSCORE_REMOVE_STATE_REMOVE_NEXT_UNDERSCORE;
-			goto copy;
-		default:
-			state = UNDERSCORE_REMOVE_STATE_DO_NOT_REMOVE_NEXT_UNDERSCORE;
-			goto copy;
-		}
-
-copy:
-		*out_ch = *in_ch;
-		in_ch++;
-		out_ch++;
-	}
-
-end:
-	return ret;
-}
-
 static
 int is_unary_string(struct bt_list_head *head)
 {
@@ -874,7 +830,8 @@ int is_unary_unsigned(struct bt_list_head *head)
 }
 
 static
-int get_unary_unsigned(struct bt_list_head *head, uint64_t *value)
+int get_unary_unsigned(struct ctx *ctx, struct bt_list_head *head,
+		uint64_t *value)
 {
 	int i = 0;
 	int ret = 0;
@@ -894,7 +851,7 @@ int get_unary_unsigned(struct bt_list_head *head, uint64_t *value)
 			uexpr_type != UNARY_UNSIGNED_CONSTANT ||
 			uexpr_link != UNARY_LINK_UNKNOWN || i != 0;
 		if (cond) {
-			_BT_LOGE_NODE(node, "Invalid constant unsigned integer.");
+			_BT_COMP_LOGE_NODE(node, "Invalid constant unsigned integer.");
 			ret = -EINVAL;
 			goto end;
 		}
@@ -966,7 +923,8 @@ end:
 }
 
 static
-int get_unary_uuid(struct bt_list_head *head, unsigned char *uuid)
+int get_unary_uuid(struct ctx *ctx, struct bt_list_head *head,
+		uint8_t *uuid)
 {
 	int i = 0;
 	int ret = 0;
@@ -986,9 +944,9 @@ int get_unary_uuid(struct bt_list_head *head, unsigned char *uuid)
 		}
 
 		src_string = node->u.unary_expression.u.string;
-		ret = bt_uuid_parse(src_string, uuid);
+		ret = bt_uuid_from_str(src_string, uuid);
 		if (ret) {
-			_BT_LOGE_NODE(node,
+			_BT_COMP_LOGE_NODE(node,
 				"Cannot parse UUID: uuid=\"%s\"", src_string);
 			goto end;
 		}
@@ -999,12 +957,12 @@ end:
 }
 
 static
-int get_boolean(struct ctf_node *unary_expr)
+int get_boolean(struct ctx *ctx, struct ctf_node *unary_expr)
 {
 	int ret = 0;
 
 	if (unary_expr->type != NODE_UNARY_EXPRESSION) {
-		_BT_LOGE_NODE(unary_expr,
+		_BT_COMP_LOGE_NODE(unary_expr,
 			"Expecting unary expression: node-type=%d",
 			unary_expr->type);
 		ret = -EINVAL;
@@ -1022,12 +980,12 @@ int get_boolean(struct ctf_node *unary_expr)
 	{
 		const char *str = unary_expr->u.unary_expression.u.string;
 
-		if (!strcmp(str, "true") || !strcmp(str, "TRUE")) {
+		if (strcmp(str, "true") == 0 || strcmp(str, "TRUE") == 0) {
 			ret = TRUE;
-		} else if (!strcmp(str, "false") || !strcmp(str, "FALSE")) {
+		} else if (strcmp(str, "false") == 0 || strcmp(str, "FALSE") == 0) {
 			ret = FALSE;
 		} else {
-			_BT_LOGE_NODE(unary_expr,
+			_BT_COMP_LOGE_NODE(unary_expr,
 				"Unexpected boolean value: value=\"%s\"", str);
 			ret = -EINVAL;
 			goto end;
@@ -1035,7 +993,7 @@ int get_boolean(struct ctf_node *unary_expr)
 		break;
 	}
 	default:
-		_BT_LOGE_NODE(unary_expr,
+		_BT_COMP_LOGE_NODE(unary_expr,
 			"Unexpected unary expression type: node-type=%d",
 			unary_expr->u.unary_expression.type);
 		ret = -EINVAL;
@@ -1047,27 +1005,28 @@ end:
 }
 
 static
-enum ctf_byte_order byte_order_from_unary_expr(struct ctf_node *unary_expr)
+enum ctf_byte_order byte_order_from_unary_expr(struct ctx *ctx,
+		struct ctf_node *unary_expr)
 {
 	const char *str;
 	enum ctf_byte_order bo = -1;
 
 	if (unary_expr->u.unary_expression.type != UNARY_STRING) {
-		_BT_LOGE_NODE(unary_expr,
+		_BT_COMP_LOGE_NODE(unary_expr,
 			"\"byte_order\" attribute: expecting `be`, `le`, `network`, or `native`.");
 		goto end;
 	}
 
 	str = unary_expr->u.unary_expression.u.string;
 
-	if (!strcmp(str, "be") || !strcmp(str, "network")) {
+	if (strcmp(str, "be") == 0 || strcmp(str, "network") == 0) {
 		bo = CTF_BYTE_ORDER_BIG;
-	} else if (!strcmp(str, "le")) {
+	} else if (strcmp(str, "le") == 0) {
 		bo = CTF_BYTE_ORDER_LITTLE;
-	} else if (!strcmp(str, "native")) {
+	} else if (strcmp(str, "native") == 0) {
 		bo = CTF_BYTE_ORDER_DEFAULT;
 	} else {
-		_BT_LOGE_NODE(unary_expr,
+		_BT_COMP_LOGE_NODE(unary_expr,
 			"Unexpected \"byte_order\" attribute value: "
 			"expecting `be`, `le`, `network`, or `native`: value=\"%s\"",
 			str);
@@ -1082,7 +1041,7 @@ static
 enum ctf_byte_order get_real_byte_order(struct ctx *ctx,
 		struct ctf_node *uexpr)
 {
-	enum ctf_byte_order bo = byte_order_from_unary_expr(uexpr);
+	enum ctf_byte_order bo = byte_order_from_unary_expr(ctx, uexpr);
 
 	if (bo == CTF_BYTE_ORDER_DEFAULT) {
 		bo = ctx->ctf_tc->default_byte_order;
@@ -1104,7 +1063,7 @@ int get_class_specifier_name(struct ctx *ctx, struct ctf_node *cls_specifier,
 	int ret = 0;
 
 	if (cls_specifier->type != NODE_TYPE_SPECIFIER) {
-		_BT_LOGE_NODE(cls_specifier,
+		_BT_COMP_LOGE_NODE(cls_specifier,
 			"Unexpected node type: node-type=%d",
 			cls_specifier->type);
 		ret = -EINVAL;
@@ -1162,7 +1121,7 @@ int get_class_specifier_name(struct ctx *ctx, struct ctf_node *cls_specifier,
 		struct ctf_node *node = cls_specifier->u.field_class_specifier.node;
 
 		if (!node->u._struct.name) {
-			_BT_LOGE_NODE(node, "Unexpected empty structure field class name.");
+			_BT_COMP_LOGE_NODE(node, "Unexpected empty structure field class name.");
 			ret = -EINVAL;
 			goto end;
 		}
@@ -1176,7 +1135,7 @@ int get_class_specifier_name(struct ctx *ctx, struct ctf_node *cls_specifier,
 		struct ctf_node *node = cls_specifier->u.field_class_specifier.node;
 
 		if (!node->u.variant.name) {
-			_BT_LOGE_NODE(node, "Unexpected empty variant field class name.");
+			_BT_COMP_LOGE_NODE(node, "Unexpected empty variant field class name.");
 			ret = -EINVAL;
 			goto end;
 		}
@@ -1190,7 +1149,7 @@ int get_class_specifier_name(struct ctx *ctx, struct ctf_node *cls_specifier,
 		struct ctf_node *node = cls_specifier->u.field_class_specifier.node;
 
 		if (!node->u._enum.enum_id) {
-			_BT_LOGE_NODE(node,
+			_BT_COMP_LOGE_NODE(node,
 				"Unexpected empty enumeration field class (`enum`) name.");
 			ret = -EINVAL;
 			goto end;
@@ -1204,7 +1163,7 @@ int get_class_specifier_name(struct ctx *ctx, struct ctf_node *cls_specifier,
 	case TYPESPEC_INTEGER:
 	case TYPESPEC_STRING:
 	default:
-		_BT_LOGE_NODE(cls_specifier->u.field_class_specifier.node,
+		_BT_COMP_LOGE_NODE(cls_specifier->u.field_class_specifier.node,
 			"Unexpected field class specifier type: %d",
 			cls_specifier->u.field_class_specifier.type);
 		ret = -EINVAL;
@@ -1296,7 +1255,7 @@ int visit_field_class_declarator(struct ctx *ctx,
 	if (node_field_class_declarator) {
 		if (node_field_class_declarator->u.field_class_declarator.type ==
 				TYPEDEC_UNKNOWN) {
-			_BT_LOGE_NODE(node_field_class_declarator,
+			_BT_COMP_LOGE_NODE(node_field_class_declarator,
 				"Unexpected field class declarator type: type=%d",
 				node_field_class_declarator->u.field_class_declarator.type);
 			ret = -EINVAL;
@@ -1306,7 +1265,7 @@ int visit_field_class_declarator(struct ctx *ctx,
 		/* TODO: GCC bitfields not supported yet */
 		if (node_field_class_declarator->u.field_class_declarator.bitfield_len !=
 				NULL) {
-			_BT_LOGE_NODE(node_field_class_declarator,
+			_BT_COMP_LOGE_NODE(node_field_class_declarator,
 				"GCC bitfields are not supported as of this version.");
 			ret = -EPERM;
 			goto error;
@@ -1329,10 +1288,11 @@ int visit_field_class_declarator(struct ctx *ctx,
 			qalias = create_class_alias_identifier(ctx,
 				cls_specifier_list, node_field_class_declarator);
 			nested_decl =
-				ctx_decl_scope_lookup_alias(ctx->current_scope,
+				ctx_decl_scope_lookup_alias(ctx,
+					ctx->current_scope,
 					g_quark_to_string(qalias), -1, true);
 			if (!nested_decl) {
-				_BT_LOGE_NODE(node_field_class_declarator,
+				_BT_COMP_LOGE_NODE(node_field_class_declarator,
 					"Cannot find class alias: name=\"%s\"",
 					g_quark_to_string(qalias));
 				ret = -EINVAL;
@@ -1370,10 +1330,6 @@ int visit_field_class_declarator(struct ctx *ctx,
 			const char *id =
 				node_field_class_declarator->u.field_class_declarator.u.id;
 
-			if (id[0] == '_') {
-				id++;
-			}
-
 			*field_name = g_quark_from_string(id);
 		} else {
 			*field_name = 0;
@@ -1392,7 +1348,7 @@ int visit_field_class_declarator(struct ctx *ctx,
 
 		/* Create array/sequence, pass nested_decl as child */
 		if (bt_list_empty(length)) {
-			_BT_LOGE_NODE(node_field_class_declarator,
+			_BT_COMP_LOGE_NODE(node_field_class_declarator,
 				"Expecting length field reference or value.");
 			ret = -EINVAL;
 			goto error;
@@ -1400,7 +1356,7 @@ int visit_field_class_declarator(struct ctx *ctx,
 
 		first = _BT_LIST_FIRST_ENTRY(length, struct ctf_node, siblings);
 		if (first->type != NODE_UNARY_EXPRESSION) {
-			_BT_LOGE_NODE(first,
+			_BT_COMP_LOGE_NODE(first,
 				"Unexpected node type: node-type=%d",
 				first->type);
 			ret = -EINVAL;
@@ -1428,7 +1384,7 @@ int visit_field_class_declarator(struct ctx *ctx,
 			char *length_name = concatenate_unary_strings(length);
 
 			if (!length_name) {
-				_BT_LOGE_NODE(node_field_class_declarator,
+				_BT_COMP_LOGE_NODE(node_field_class_declarator,
 					"Cannot concatenate unary strings.");
 				ret = -EINVAL;
 				goto error;
@@ -1443,7 +1399,7 @@ int visit_field_class_declarator(struct ctx *ctx,
 				struct ctf_field_class_array *array_decl;
 
 				if (!env_entry) {
-					_BT_LOGE_NODE(node_field_class_declarator,
+					_BT_COMP_LOGE_NODE(node_field_class_declarator,
 						"Cannot find environment entry: "
 						"name=\"%s\"", env_entry_name);
 					ret = -EINVAL;
@@ -1451,7 +1407,7 @@ int visit_field_class_declarator(struct ctx *ctx,
 				}
 
 				if (env_entry->type != CTF_TRACE_CLASS_ENV_ENTRY_TYPE_INT) {
-					_BT_LOGE_NODE(node_field_class_declarator,
+					_BT_COMP_LOGE_NODE(node_field_class_declarator,
 						"Wrong environment entry type "
 						"(expecting integer): "
 						"name=\"%s\"", env_entry_name);
@@ -1460,7 +1416,7 @@ int visit_field_class_declarator(struct ctx *ctx,
 				}
 
 				if (env_entry->value.i < 0) {
-					_BT_LOGE_NODE(node_field_class_declarator,
+					_BT_COMP_LOGE_NODE(node_field_class_declarator,
 						"Invalid, negative array length: "
 						"env-entry-name=\"%s\", "
 						"value=%" PRId64,
@@ -1478,24 +1434,12 @@ int visit_field_class_declarator(struct ctx *ctx,
 				nested_decl = NULL;
 				decl = (void *) array_decl;
 			} else {
-				char *length_name_no_underscore =
-					remove_underscores_from_field_ref(
-						length_name);
-				if (!length_name_no_underscore) {
-					/*
-					 * remove_underscores_from_field_ref()
-					 * logs errors
-					 */
-					ret = -EINVAL;
-					goto error;
-				}
 				seq_decl = ctf_field_class_sequence_create();
 				BT_ASSERT(seq_decl);
 				seq_decl->base.elem_fc = nested_decl;
 				nested_decl = NULL;
 				g_string_assign(seq_decl->length_ref,
-					length_name_no_underscore);
-				free(length_name_no_underscore);
+					length_name);
 				decl = (void *) seq_decl;
 			}
 
@@ -1571,7 +1515,7 @@ int visit_struct_decl_field(struct ctx *ctx,
 			&qfield_name, iter, &field_decl, NULL);
 		if (ret) {
 			BT_ASSERT(!field_decl);
-			_BT_LOGE_NODE(cls_specifier_list,
+			_BT_COMP_LOGE_NODE(cls_specifier_list,
 				"Cannot visit field class declarator: ret=%d", ret);
 			goto error;
 		}
@@ -1582,7 +1526,7 @@ int visit_struct_decl_field(struct ctx *ctx,
 		/* Check if field with same name already exists */
 		if (ctf_field_class_struct_borrow_member_by_name(
 				struct_decl, field_name)) {
-			_BT_LOGE_NODE(cls_specifier_list,
+			_BT_COMP_LOGE_NODE(cls_specifier_list,
 				"Duplicate field in structure field class: "
 				"field-name=\"%s\"", field_name);
 			ret = -EINVAL;
@@ -1622,7 +1566,7 @@ int visit_variant_decl_field(struct ctx *ctx,
 			&qfield_name, iter, &field_decl, NULL);
 		if (ret) {
 			BT_ASSERT(!field_decl);
-			_BT_LOGE_NODE(cls_specifier_list,
+			_BT_COMP_LOGE_NODE(cls_specifier_list,
 				"Cannot visit field class declarator: ret=%d", ret);
 			goto error;
 		}
@@ -1633,7 +1577,7 @@ int visit_variant_decl_field(struct ctx *ctx,
 		/* Check if field with same name already exists */
 		if (ctf_field_class_variant_borrow_option_by_name(
 				variant_decl, field_name)) {
-			_BT_LOGE_NODE(cls_specifier_list,
+			_BT_COMP_LOGE_NODE(cls_specifier_list,
 				"Duplicate field in variant field class: "
 				"field-name=\"%s\"", field_name);
 			ret = -EINVAL;
@@ -1667,7 +1611,7 @@ int visit_field_class_def(struct ctx *ctx, struct ctf_node *cls_specifier_list,
 		ret = visit_field_class_declarator(ctx, cls_specifier_list,
 			&qidentifier, iter, &class_decl, NULL);
 		if (ret) {
-			_BT_LOGE_NODE(iter,
+			_BT_COMP_LOGE_NODE(iter,
 				"Cannot visit field class declarator: ret=%d", ret);
 			ret = -EINVAL;
 			goto end;
@@ -1679,17 +1623,17 @@ int visit_field_class_def(struct ctx *ctx, struct ctf_node *cls_specifier_list,
 				(void *) class_decl;
 
 			if (var_fc->tag_path.path->len == 0) {
-				_BT_LOGE_NODE(iter,
+				_BT_COMP_LOGE_NODE(iter,
 					"Type definition of untagged variant field class is not allowed.");
 				ret = -EPERM;
 				goto end;
 			}
 		}
 
-		ret = ctx_decl_scope_register_alias(ctx->current_scope,
+		ret = ctx_decl_scope_register_alias(ctx, ctx->current_scope,
 			g_quark_to_string(qidentifier), class_decl);
 		if (ret) {
-			_BT_LOGE_NODE(iter,
+			_BT_COMP_LOGE_NODE(iter,
 				"Cannot register field class alias: name=\"%s\"",
 				g_quark_to_string(qidentifier));
 			goto end;
@@ -1726,7 +1670,7 @@ int visit_field_class_alias(struct ctx *ctx, struct ctf_node *target,
 		&qdummy_field_name, node, &class_decl, NULL);
 	if (ret) {
 		BT_ASSERT(!class_decl);
-		_BT_LOGE_NODE(node,
+		_BT_COMP_LOGE_NODE(node,
 			"Cannot visit field class declarator: ret=%d", ret);
 		goto end;
 	}
@@ -1736,7 +1680,7 @@ int visit_field_class_alias(struct ctx *ctx, struct ctf_node *target,
 		struct ctf_field_class_variant *var_fc = (void *) class_decl;
 
 		if (var_fc->tag_path.path->len == 0) {
-			_BT_LOGE_NODE(target,
+			_BT_COMP_LOGE_NODE(target,
 				"Type definition of untagged variant field class is not allowed.");
 			ret = -EPERM;
 			goto end;
@@ -1748,7 +1692,7 @@ int visit_field_class_alias(struct ctx *ctx, struct ctf_node *target,
 	 * abstract or not (if it has an identifier). Check it here.
 	 */
 	if (qdummy_field_name != 0) {
-		_BT_LOGE_NODE(target,
+		_BT_COMP_LOGE_NODE(target,
 			"Expecting empty identifier: id=\"%s\"",
 			g_quark_to_string(qdummy_field_name));
 		ret = -EINVAL;
@@ -1760,10 +1704,10 @@ int visit_field_class_alias(struct ctx *ctx, struct ctf_node *target,
 		struct ctf_node, siblings);
 	qalias = create_class_alias_identifier(ctx,
 		alias->u.field_class_alias_name.field_class_specifier_list, node);
-	ret = ctx_decl_scope_register_alias(ctx->current_scope,
+	ret = ctx_decl_scope_register_alias(ctx, ctx->current_scope,
 		g_quark_to_string(qalias), class_decl);
 	if (ret) {
-		_BT_LOGE_NODE(node,
+		_BT_COMP_LOGE_NODE(node,
 			"Cannot register class alias: name=\"%s\"",
 			g_quark_to_string(qalias));
 		goto end;
@@ -1787,7 +1731,7 @@ int visit_struct_decl_entry(struct ctx *ctx, struct ctf_node *entry_node,
 			entry_node->u.field_class_def.field_class_specifier_list,
 			&entry_node->u.field_class_def.field_class_declarators);
 		if (ret) {
-			_BT_LOGE_NODE(entry_node,
+			_BT_COMP_LOGE_NODE(entry_node,
 				"Cannot add field class found in structure field class: ret=%d",
 				ret);
 			goto end;
@@ -1797,7 +1741,7 @@ int visit_struct_decl_entry(struct ctx *ctx, struct ctf_node *entry_node,
 		ret = visit_field_class_alias(ctx, entry_node->u.field_class_alias.target,
 			entry_node->u.field_class_alias.alias);
 		if (ret) {
-			_BT_LOGE_NODE(entry_node,
+			_BT_COMP_LOGE_NODE(entry_node,
 				"Cannot add field class alias found in structure field class: ret=%d",
 				ret);
 			goto end;
@@ -1815,7 +1759,7 @@ int visit_struct_decl_entry(struct ctx *ctx, struct ctf_node *entry_node,
 		}
 		break;
 	default:
-		_BT_LOGE_NODE(entry_node,
+		_BT_COMP_LOGE_NODE(entry_node,
 			"Unexpected node type: node-type=%d", entry_node->type);
 		ret = -EINVAL;
 		goto end;
@@ -1837,7 +1781,7 @@ int visit_variant_decl_entry(struct ctx *ctx, struct ctf_node *entry_node,
 			entry_node->u.field_class_def.field_class_specifier_list,
 			&entry_node->u.field_class_def.field_class_declarators);
 		if (ret) {
-			_BT_LOGE_NODE(entry_node,
+			_BT_COMP_LOGE_NODE(entry_node,
 				"Cannot add field class found in variant field class: ret=%d",
 				ret);
 			goto end;
@@ -1847,7 +1791,7 @@ int visit_variant_decl_entry(struct ctx *ctx, struct ctf_node *entry_node,
 		ret = visit_field_class_alias(ctx, entry_node->u.field_class_alias.target,
 			entry_node->u.field_class_alias.alias);
 		if (ret) {
-			_BT_LOGE_NODE(entry_node,
+			_BT_COMP_LOGE_NODE(entry_node,
 				"Cannot add field class alias found in variant field class: ret=%d",
 				ret);
 			goto end;
@@ -1865,7 +1809,7 @@ int visit_variant_decl_entry(struct ctx *ctx, struct ctf_node *entry_node,
 		}
 		break;
 	default:
-		_BT_LOGE_NODE(entry_node,
+		_BT_COMP_LOGE_NODE(entry_node,
 			"Unexpected node type: node-type=%d",
 			entry_node->type);
 		ret = -EINVAL;
@@ -1890,15 +1834,15 @@ int visit_struct_decl(struct ctx *ctx, const char *name,
 	/* For named struct (without body), lookup in declaration scope */
 	if (!has_body) {
 		if (!name) {
-			BT_LOGE_STR("Bodyless structure field class: missing name.");
+			BT_COMP_LOGE_STR("Bodyless structure field class: missing name.");
 			ret = -EPERM;
 			goto error;
 		}
 
-		*struct_decl = ctx_decl_scope_lookup_struct(ctx->current_scope,
+		*struct_decl = ctx_decl_scope_lookup_struct(ctx, ctx->current_scope,
 			name, -1, true);
 		if (!*struct_decl) {
-			BT_LOGE("Cannot find structure field class: name=\"struct %s\"",
+			BT_COMP_LOGE("Cannot find structure field class: name=\"struct %s\"",
 				name);
 			ret = -EINVAL;
 			goto error;
@@ -1908,9 +1852,9 @@ int visit_struct_decl(struct ctx *ctx, const char *name,
 		uint64_t min_align_value = 0;
 
 		if (name) {
-			if (ctx_decl_scope_lookup_struct(
+			if (ctx_decl_scope_lookup_struct(ctx,
 					ctx->current_scope, name, 1, false)) {
-				BT_LOGE("Structure field class already declared in local scope: "
+				BT_COMP_LOGE("Structure field class already declared in local scope: "
 					"name=\"struct %s\"", name);
 				ret = -EINVAL;
 				goto error;
@@ -1918,9 +1862,10 @@ int visit_struct_decl(struct ctx *ctx, const char *name,
 		}
 
 		if (!bt_list_empty(min_align)) {
-			ret = get_unary_unsigned(min_align, &min_align_value);
+			ret = get_unary_unsigned(ctx, min_align,
+				&min_align_value);
 			if (ret) {
-				BT_LOGE("Unexpected unary expression for structure field class's `align` attribute: "
+				BT_COMP_LOGE("Unexpected unary expression for structure field class's `align` attribute: "
 					"ret=%d", ret);
 				goto error;
 			}
@@ -1939,7 +1884,7 @@ int visit_struct_decl(struct ctx *ctx, const char *name,
 			ret = visit_struct_decl_entry(ctx, entry_node,
 				*struct_decl);
 			if (ret) {
-				_BT_LOGE_NODE(entry_node,
+				_BT_COMP_LOGE_NODE(entry_node,
 					"Cannot visit structure field class entry: "
 					"ret=%d", ret);
 				ctx_pop_scope(ctx);
@@ -1950,10 +1895,10 @@ int visit_struct_decl(struct ctx *ctx, const char *name,
 		ctx_pop_scope(ctx);
 
 		if (name) {
-			ret = ctx_decl_scope_register_struct(ctx->current_scope,
-				name, *struct_decl);
+			ret = ctx_decl_scope_register_struct(ctx,
+				ctx->current_scope, name, *struct_decl);
 			if (ret) {
-				BT_LOGE("Cannot register structure field class in declaration scope: "
+				BT_COMP_LOGE("Cannot register structure field class in declaration scope: "
 					"name=\"struct %s\", ret=%d", name, ret);
 				goto error;
 			}
@@ -1982,16 +1927,16 @@ int visit_variant_decl(struct ctx *ctx, const char *name,
 	/* For named variant (without body), lookup in declaration scope */
 	if (!has_body) {
 		if (!name) {
-			BT_LOGE_STR("Bodyless variant field class: missing name.");
+			BT_COMP_LOGE_STR("Bodyless variant field class: missing name.");
 			ret = -EPERM;
 			goto error;
 		}
 
 		untagged_variant_decl =
-			ctx_decl_scope_lookup_variant(ctx->current_scope,
+			ctx_decl_scope_lookup_variant(ctx, ctx->current_scope,
 				name, -1, true);
 		if (!untagged_variant_decl) {
-			BT_LOGE("Cannot find variant field class: name=\"variant %s\"",
+			BT_COMP_LOGE("Cannot find variant field class: name=\"variant %s\"",
 				name);
 			ret = -EINVAL;
 			goto error;
@@ -2000,9 +1945,9 @@ int visit_variant_decl(struct ctx *ctx, const char *name,
 		struct ctf_node *entry_node;
 
 		if (name) {
-			if (ctx_decl_scope_lookup_variant(ctx->current_scope,
-					name, 1, false)) {
-				BT_LOGE("Variant field class already declared in local scope: "
+			if (ctx_decl_scope_lookup_variant(ctx,
+					ctx->current_scope, name, 1, false)) {
+				BT_COMP_LOGE("Variant field class already declared in local scope: "
 					"name=\"variant %s\"", name);
 				ret = -EINVAL;
 				goto error;
@@ -2017,7 +1962,7 @@ int visit_variant_decl(struct ctx *ctx, const char *name,
 			ret = visit_variant_decl_entry(ctx, entry_node,
 				untagged_variant_decl);
 			if (ret) {
-				_BT_LOGE_NODE(entry_node,
+				_BT_COMP_LOGE_NODE(entry_node,
 					"Cannot visit variant field class entry: "
 					"ret=%d", ret);
 				ctx_pop_scope(ctx);
@@ -2028,11 +1973,11 @@ int visit_variant_decl(struct ctx *ctx, const char *name,
 		ctx_pop_scope(ctx);
 
 		if (name) {
-			ret = ctx_decl_scope_register_variant(
+			ret = ctx_decl_scope_register_variant(ctx,
 				ctx->current_scope, name,
 				untagged_variant_decl);
 			if (ret) {
-				BT_LOGE("Cannot register variant field class in declaration scope: "
+				BT_COMP_LOGE("Cannot register variant field class in declaration scope: "
 					"name=\"variant %s\", ret=%d", name, ret);
 				goto error;
 			}
@@ -2051,17 +1996,7 @@ int visit_variant_decl(struct ctx *ctx, const char *name,
 		 * At this point, we have a fresh untagged variant; nobody
 		 * else owns it. Set its tag now.
 		 */
-		char *tag_no_underscore =
-			remove_underscores_from_field_ref(tag);
-
-		if (!tag_no_underscore) {
-			/* remove_underscores_from_field_ref() logs errors */
-			goto error;
-		}
-
-		g_string_assign(untagged_variant_decl->tag_ref,
-			tag_no_underscore);
-		free(tag_no_underscore);
+		g_string_assign(untagged_variant_decl->tag_ref, tag);
 		*variant_decl = untagged_variant_decl;
 		untagged_variant_decl = NULL;
 	}
@@ -2102,14 +2037,13 @@ int visit_enum_decl_entry(struct ctx *ctx, struct ctf_node *enumerator,
 		.value.u = 0,
 	};
 	const char *label = enumerator->u.enumerator.id;
-	const char *effective_label = label;
 	struct bt_list_head *values = &enumerator->u.enumerator.values;
 
 	bt_list_for_each_entry(iter, values, siblings) {
 		struct uori *target;
 
 		if (iter->type != NODE_UNARY_EXPRESSION) {
-			_BT_LOGE_NODE(iter,
+			_BT_COMP_LOGE_NODE(iter,
 				"Wrong expression for enumeration field class label: "
 				"node-type=%d, label=\"%s\"", iter->type,
 				label);
@@ -2135,7 +2069,7 @@ int visit_enum_decl_entry(struct ctx *ctx, struct ctf_node *enumerator,
 				iter->u.unary_expression.u.unsigned_constant;
 			break;
 		default:
-			_BT_LOGE_NODE(iter,
+			_BT_COMP_LOGE_NODE(iter,
 				"Invalid enumeration field class entry: "
 				"expecting constant signed or unsigned integer: "
 				"node-type=%d, label=\"%s\"",
@@ -2145,7 +2079,7 @@ int visit_enum_decl_entry(struct ctx *ctx, struct ctf_node *enumerator,
 		}
 
 		if (nr_vals > 1) {
-			_BT_LOGE_NODE(iter,
+			_BT_COMP_LOGE_NODE(iter,
 				"Invalid enumeration field class entry: label=\"%s\"",
 				label);
 			ret = -EINVAL;
@@ -2169,19 +2103,7 @@ int visit_enum_decl_entry(struct ctx *ctx, struct ctf_node *enumerator,
 		last->value.u = end.value.u + 1;
 	}
 
-	if (label[0] == '_') {
-		/*
-		 * Strip the first underscore of any enumeration field
-		 * class's label in case this enumeration FC is used as
-		 * a variant FC tag later. The variant FC choice names
-		 * could also start with `_`, in which case the prefix
-		 * is removed, and it the resulting choice name needs to
-		 * match tag labels.
-		 */
-		effective_label = &label[1];
-	}
-
-	ctf_field_class_enum_append_mapping(enum_decl, effective_label,
+	ctf_field_class_enum_map_range(enum_decl, label,
 		start.value.u, end.value.u);
 	return 0;
 
@@ -2205,15 +2127,15 @@ int visit_enum_decl(struct ctx *ctx, const char *name,
 	/* For named enum (without body), lookup in declaration scope */
 	if (!has_body) {
 		if (!name) {
-			BT_LOGE_STR("Bodyless enumeration field class: missing name.");
+			BT_COMP_LOGE_STR("Bodyless enumeration field class: missing name.");
 			ret = -EPERM;
 			goto error;
 		}
 
-		*enum_decl = ctx_decl_scope_lookup_enum(ctx->current_scope,
+		*enum_decl = ctx_decl_scope_lookup_enum(ctx, ctx->current_scope,
 			name, -1, true);
 		if (!*enum_decl) {
-			BT_LOGE("Cannot find enumeration field class: "
+			BT_COMP_LOGE("Cannot find enumeration field class: "
 				"name=\"enum %s\"", name);
 			ret = -EINVAL;
 			goto error;
@@ -2226,9 +2148,9 @@ int visit_enum_decl(struct ctx *ctx, const char *name,
 		};
 
 		if (name) {
-			if (ctx_decl_scope_lookup_enum(ctx->current_scope,
+			if (ctx_decl_scope_lookup_enum(ctx, ctx->current_scope,
 					name, 1, false)) {
-				BT_LOGE("Enumeration field class already declared in local scope: "
+				BT_COMP_LOGE("Enumeration field class already declared in local scope: "
 					"name=\"enum %s\"", name);
 				ret = -EINVAL;
 				goto error;
@@ -2236,10 +2158,10 @@ int visit_enum_decl(struct ctx *ctx, const char *name,
 		}
 
 		if (!container_cls) {
-			integer_decl = (void *) ctx_decl_scope_lookup_alias(
+			integer_decl = (void *) ctx_decl_scope_lookup_alias(ctx,
 				ctx->current_scope, "int", -1, true);
 			if (!integer_decl) {
-				BT_LOGE_STR("Cannot find implicit `int` field class alias for enumeration field class.");
+				BT_COMP_LOGE_STR("Cannot find implicit `int` field class alias for enumeration field class.");
 				ret = -EINVAL;
 				goto error;
 			}
@@ -2257,7 +2179,7 @@ int visit_enum_decl(struct ctx *ctx, const char *name,
 		BT_ASSERT(integer_decl);
 
 		if (integer_decl->base.base.type != CTF_FIELD_CLASS_TYPE_INT) {
-			BT_LOGE("Container field class for enumeration field class is not an integer field class: "
+			BT_COMP_LOGE("Container field class for enumeration field class is not an integer field class: "
 				"fc-type=%d", integer_decl->base.base.type);
 			ret = -EINVAL;
 			goto error;
@@ -2275,7 +2197,7 @@ int visit_enum_decl(struct ctx *ctx, const char *name,
 			ret = visit_enum_decl_entry(ctx, iter, *enum_decl,
 				&last_value);
 			if (ret) {
-				_BT_LOGE_NODE(iter,
+				_BT_COMP_LOGE_NODE(iter,
 					"Cannot visit enumeration field class entry: "
 					"ret=%d", ret);
 				goto error;
@@ -2283,10 +2205,10 @@ int visit_enum_decl(struct ctx *ctx, const char *name,
 		}
 
 		if (name) {
-			ret = ctx_decl_scope_register_enum(ctx->current_scope,
-				name, *enum_decl);
+			ret = ctx_decl_scope_register_enum(ctx,
+				ctx->current_scope, name, *enum_decl);
 			if (ret) {
-				BT_LOGE("Cannot register enumeration field class in declaration scope: "
+				BT_COMP_LOGE("Cannot register enumeration field class in declaration scope: "
 					"ret=%d", ret);
 				goto error;
 			}
@@ -2317,15 +2239,15 @@ int visit_field_class_specifier(struct ctx *ctx,
 	str = g_string_new("");
 	ret = get_class_specifier_list_name(ctx, cls_specifier_list, str);
 	if (ret) {
-		_BT_LOGE_NODE(cls_specifier_list,
+		_BT_COMP_LOGE_NODE(cls_specifier_list,
 			"Cannot get field class specifier list's name: ret=%d", ret);
 		goto error;
 	}
 
-	*decl = ctx_decl_scope_lookup_alias(ctx->current_scope, str->str, -1,
-		true);
+	*decl = ctx_decl_scope_lookup_alias(ctx, ctx->current_scope, str->str,
+		-1, true);
 	if (!*decl) {
-		_BT_LOGE_NODE(cls_specifier_list,
+		_BT_COMP_LOGE_NODE(cls_specifier_list,
 			"Cannot find field class alias: name=\"%s\"", str->str);
 		ret = -EINVAL;
 		goto error;
@@ -2373,24 +2295,24 @@ int visit_integer_decl(struct ctx *ctx,
 			siblings);
 
 		if (left->u.unary_expression.type != UNARY_STRING) {
-			_BT_LOGE_NODE(left,
+			_BT_COMP_LOGE_NODE(left,
 				"Unexpected unary expression type: type=%d",
 				left->u.unary_expression.type);
 			ret = -EINVAL;
 			goto error;
 		}
 
-		if (!strcmp(left->u.unary_expression.u.string, "signed")) {
+		if (strcmp(left->u.unary_expression.u.string, "signed") == 0) {
 			if (_IS_SET(&set, _INTEGER_SIGNED_SET)) {
-				_BT_LOGE_DUP_ATTR(left, "signed",
+				_BT_COMP_LOGE_DUP_ATTR(left, "signed",
 					"integer field class");
 				ret = -EPERM;
 				goto error;
 			}
 
-			signedness = get_boolean(right);
+			signedness = get_boolean(ctx, right);
 			if (signedness < 0) {
-				_BT_LOGE_NODE(right,
+				_BT_COMP_LOGE_NODE(right,
 					"Invalid boolean value for integer field class's `signed` attribute: "
 					"ret=%d", ret);
 				ret = -EINVAL;
@@ -2398,10 +2320,9 @@ int visit_integer_decl(struct ctx *ctx,
 			}
 
 			_SET(&set, _INTEGER_SIGNED_SET);
-		} else if (!strcmp(left->u.unary_expression.u.string,
-				"byte_order")) {
+		} else if (strcmp(left->u.unary_expression.u.string, "byte_order") == 0) {
 			if (_IS_SET(&set, _INTEGER_BYTE_ORDER_SET)) {
-				_BT_LOGE_DUP_ATTR(left, "byte_order",
+				_BT_COMP_LOGE_DUP_ATTR(left, "byte_order",
 					"integer field class");
 				ret = -EPERM;
 				goto error;
@@ -2409,7 +2330,7 @@ int visit_integer_decl(struct ctx *ctx,
 
 			byte_order = get_real_byte_order(ctx, right);
 			if (byte_order == -1) {
-				_BT_LOGE_NODE(right,
+				_BT_COMP_LOGE_NODE(right,
 					"Invalid `byte_order` attribute in integer field class: "
 					"ret=%d", ret);
 				ret = -EINVAL;
@@ -2417,9 +2338,9 @@ int visit_integer_decl(struct ctx *ctx,
 			}
 
 			_SET(&set, _INTEGER_BYTE_ORDER_SET);
-		} else if (!strcmp(left->u.unary_expression.u.string, "size")) {
+		} else if (strcmp(left->u.unary_expression.u.string, "size") == 0) {
 			if (_IS_SET(&set, _INTEGER_SIZE_SET)) {
-				_BT_LOGE_DUP_ATTR(left, "size",
+				_BT_COMP_LOGE_DUP_ATTR(left, "size",
 					"integer field class");
 				ret = -EPERM;
 				goto error;
@@ -2427,7 +2348,7 @@ int visit_integer_decl(struct ctx *ctx,
 
 			if (right->u.unary_expression.type !=
 					UNARY_UNSIGNED_CONSTANT) {
-				_BT_LOGE_NODE(right,
+				_BT_COMP_LOGE_NODE(right,
 					"Invalid `size` attribute in integer field class: "
 					"expecting unsigned constant integer: "
 					"node-type=%d",
@@ -2438,14 +2359,14 @@ int visit_integer_decl(struct ctx *ctx,
 
 			size = right->u.unary_expression.u.unsigned_constant;
 			if (size == 0) {
-				_BT_LOGE_NODE(right,
+				_BT_COMP_LOGE_NODE(right,
 					"Invalid `size` attribute in integer field class: "
 					"expecting positive constant integer: "
 					"size=%" PRIu64, size);
 				ret = -EINVAL;
 				goto error;
 			} else if (size > 64) {
-				_BT_LOGE_NODE(right,
+				_BT_COMP_LOGE_NODE(right,
 					"Invalid `size` attribute in integer field class: "
 					"integer fields over 64 bits are not supported as of this version: "
 					"size=%" PRIu64, size);
@@ -2454,10 +2375,9 @@ int visit_integer_decl(struct ctx *ctx,
 			}
 
 			_SET(&set, _INTEGER_SIZE_SET);
-		} else if (!strcmp(left->u.unary_expression.u.string,
-				"align")) {
+		} else if (strcmp(left->u.unary_expression.u.string, "align") == 0) {
 			if (_IS_SET(&set, _INTEGER_ALIGN_SET)) {
-				_BT_LOGE_DUP_ATTR(left, "align",
+				_BT_COMP_LOGE_DUP_ATTR(left, "align",
 					"integer field class");
 				ret = -EPERM;
 				goto error;
@@ -2465,7 +2385,7 @@ int visit_integer_decl(struct ctx *ctx,
 
 			if (right->u.unary_expression.type !=
 					UNARY_UNSIGNED_CONSTANT) {
-				_BT_LOGE_NODE(right,
+				_BT_COMP_LOGE_NODE(right,
 					"Invalid `align` attribute in integer field class: "
 					"expecting unsigned constant integer: "
 					"node-type=%d",
@@ -2477,7 +2397,7 @@ int visit_integer_decl(struct ctx *ctx,
 			alignment =
 				right->u.unary_expression.u.unsigned_constant;
 			if (!is_align_valid(alignment)) {
-				_BT_LOGE_NODE(right,
+				_BT_COMP_LOGE_NODE(right,
 					"Invalid `align` attribute in integer field class: "
 					"expecting power of two: "
 					"align=%" PRIu64, alignment);
@@ -2486,9 +2406,9 @@ int visit_integer_decl(struct ctx *ctx,
 			}
 
 			_SET(&set, _INTEGER_ALIGN_SET);
-		} else if (!strcmp(left->u.unary_expression.u.string, "base")) {
+		} else if (strcmp(left->u.unary_expression.u.string, "base") == 0) {
 			if (_IS_SET(&set, _INTEGER_BASE_SET)) {
-				_BT_LOGE_DUP_ATTR(left, "base",
+				_BT_COMP_LOGE_DUP_ATTR(left, "base",
 					"integer field class");
 				ret = -EPERM;
 				goto error;
@@ -2514,7 +2434,7 @@ int visit_integer_decl(struct ctx *ctx,
 					base = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_HEXADECIMAL;
 					break;
 				default:
-					_BT_LOGE_NODE(right,
+					_BT_COMP_LOGE_NODE(right,
 						"Invalid `base` attribute in integer field class: "
 						"base=%" PRIu64,
 						right->u.unary_expression.u.unsigned_constant);
@@ -2528,33 +2448,33 @@ int visit_integer_decl(struct ctx *ctx,
 				char *s_right = concatenate_unary_strings(
 					&expression->u.ctf_expression.right);
 				if (!s_right) {
-					_BT_LOGE_NODE(right,
+					_BT_COMP_LOGE_NODE(right,
 						"Unexpected unary expression for integer field class's `base` attribute.");
 					ret = -EINVAL;
 					goto error;
 				}
 
-				if (!strcmp(s_right, "decimal") ||
-						!strcmp(s_right, "dec") ||
-						!strcmp(s_right, "d") ||
-						!strcmp(s_right, "i") ||
-						!strcmp(s_right, "u")) {
+				if (strcmp(s_right, "decimal") == 0 ||
+						strcmp(s_right, "dec") == 0 ||
+						strcmp(s_right, "d") == 0 ||
+						strcmp(s_right, "i") == 0 ||
+						strcmp(s_right, "u") == 0) {
 					base = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL;
-				} else if (!strcmp(s_right, "hexadecimal") ||
-						!strcmp(s_right, "hex") ||
-						!strcmp(s_right, "x") ||
-						!strcmp(s_right, "X") ||
-						!strcmp(s_right, "p")) {
+				} else if (strcmp(s_right, "hexadecimal") == 0 ||
+						strcmp(s_right, "hex") == 0 ||
+						strcmp(s_right, "x") == 0 ||
+						strcmp(s_right, "X") == 0 ||
+						strcmp(s_right, "p") == 0) {
 					base = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_HEXADECIMAL;
-				} else if (!strcmp(s_right, "octal") ||
-						!strcmp(s_right, "oct") ||
-						!strcmp(s_right, "o")) {
+				} else if (strcmp(s_right, "octal") == 0 ||
+						strcmp(s_right, "oct") == 0 ||
+						strcmp(s_right, "o") == 0) {
 					base = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_OCTAL;
-				} else if (!strcmp(s_right, "binary") ||
-						!strcmp(s_right, "b")) {
+				} else if (strcmp(s_right, "binary") == 0 ||
+						strcmp(s_right, "b") == 0) {
 					base = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_BINARY;
 				} else {
-					_BT_LOGE_NODE(right,
+					_BT_COMP_LOGE_NODE(right,
 						"Unexpected unary expression for integer field class's `base` attribute: "
 						"base=\"%s\"", s_right);
 					g_free(s_right);
@@ -2566,7 +2486,7 @@ int visit_integer_decl(struct ctx *ctx,
 				break;
 			}
 			default:
-				_BT_LOGE_NODE(right,
+				_BT_COMP_LOGE_NODE(right,
 					"Invalid `base` attribute in integer field class: "
 					"expecting unsigned constant integer or unary string.");
 				ret = -EINVAL;
@@ -2574,19 +2494,18 @@ int visit_integer_decl(struct ctx *ctx,
 			}
 
 			_SET(&set, _INTEGER_BASE_SET);
-		} else if (!strcmp(left->u.unary_expression.u.string,
-				"encoding")) {
+		} else if (strcmp(left->u.unary_expression.u.string, "encoding") == 0) {
 			char *s_right;
 
 			if (_IS_SET(&set, _INTEGER_ENCODING_SET)) {
-				_BT_LOGE_DUP_ATTR(left, "encoding",
+				_BT_COMP_LOGE_DUP_ATTR(left, "encoding",
 					"integer field class");
 				ret = -EPERM;
 				goto error;
 			}
 
 			if (right->u.unary_expression.type != UNARY_STRING) {
-				_BT_LOGE_NODE(right,
+				_BT_COMP_LOGE_NODE(right,
 					"Invalid `encoding` attribute in integer field class: "
 					"expecting unary string.");
 				ret = -EINVAL;
@@ -2596,23 +2515,23 @@ int visit_integer_decl(struct ctx *ctx,
 			s_right = concatenate_unary_strings(
 				&expression->u.ctf_expression.right);
 			if (!s_right) {
-				_BT_LOGE_NODE(right,
+				_BT_COMP_LOGE_NODE(right,
 					"Unexpected unary expression for integer field class's `encoding` attribute.");
 				ret = -EINVAL;
 				goto error;
 			}
 
-			if (!strcmp(s_right, "UTF8") ||
-					!strcmp(s_right, "utf8") ||
-					!strcmp(s_right, "utf-8") ||
-					!strcmp(s_right, "UTF-8") ||
-					!strcmp(s_right, "ASCII") ||
-					!strcmp(s_right, "ascii")) {
+			if (strcmp(s_right, "UTF8") == 0 ||
+					strcmp(s_right, "utf8") == 0 ||
+					strcmp(s_right, "utf-8") == 0 ||
+					strcmp(s_right, "UTF-8") == 0 ||
+					strcmp(s_right, "ASCII") == 0 ||
+					strcmp(s_right, "ascii") == 0) {
 				encoding = CTF_ENCODING_UTF8;
-			} else if (!strcmp(s_right, "none")) {
+			} else if (strcmp(s_right, "none") == 0) {
 				encoding = CTF_ENCODING_NONE;
 			} else {
-				_BT_LOGE_NODE(right,
+				_BT_COMP_LOGE_NODE(right,
 					"Invalid `encoding` attribute in integer field class: "
 					"unknown encoding: encoding=\"%s\"",
 					s_right);
@@ -2623,18 +2542,18 @@ int visit_integer_decl(struct ctx *ctx,
 
 			g_free(s_right);
 			_SET(&set, _INTEGER_ENCODING_SET);
-		} else if (!strcmp(left->u.unary_expression.u.string, "map")) {
+		} else if (strcmp(left->u.unary_expression.u.string, "map") == 0) {
 			const char *clock_name;
 
 			if (_IS_SET(&set, _INTEGER_MAP_SET)) {
-				_BT_LOGE_DUP_ATTR(left, "map",
+				_BT_COMP_LOGE_DUP_ATTR(left, "map",
 					"integer field class");
 				ret = -EPERM;
 				goto error;
 			}
 
 			if (right->u.unary_expression.type != UNARY_STRING) {
-				_BT_LOGE_NODE(right,
+				_BT_COMP_LOGE_NODE(right,
 					"Invalid `map` attribute in integer field class: "
 					"expecting unary string.");
 				ret = -EINVAL;
@@ -2649,13 +2568,13 @@ int visit_integer_decl(struct ctx *ctx,
 					&expression->u.ctf_expression.right);
 
 				if (!s_right) {
-					_BT_LOGE_NODE(right,
+					_BT_COMP_LOGE_NODE(right,
 						"Unexpected unary expression for integer field class's `map` attribute.");
 					ret = -EINVAL;
 					goto error;
 				}
 
-				_BT_LOGE_NODE(right,
+				_BT_COMP_LOGE_NODE(right,
 					"Invalid `map` attribute in integer field class: "
 					"cannot find clock class at this point: name=\"%s\"",
 					s_right);
@@ -2668,7 +2587,7 @@ int visit_integer_decl(struct ctx *ctx,
 				ctf_trace_class_borrow_clock_class_by_name(
 					ctx->ctf_tc, clock_name);
 			if (!mapped_clock_class) {
-				_BT_LOGE_NODE(right,
+				_BT_COMP_LOGE_NODE(right,
 					"Invalid `map` attribute in integer field class: "
 					"cannot find clock class at this point: name=\"%s\"",
 					clock_name);
@@ -2678,7 +2597,7 @@ int visit_integer_decl(struct ctx *ctx,
 
 			_SET(&set, _INTEGER_MAP_SET);
 		} else {
-			_BT_LOGW_NODE(left,
+			_BT_COMP_LOGW_NODE(left,
 				"Unknown attribute in integer field class: "
 				"attr-name=\"%s\"",
 				left->u.unary_expression.u.string);
@@ -2686,7 +2605,7 @@ int visit_integer_decl(struct ctx *ctx,
 	}
 
 	if (!_IS_SET(&set, _INTEGER_SIZE_SET)) {
-		BT_LOGE_STR("Missing `size` attribute in integer field class.");
+		BT_COMP_LOGE_STR("Missing `size` attribute in integer field class.");
 		ret = -EPERM;
 		goto error;
 	}
@@ -2741,16 +2660,16 @@ int visit_floating_point_number_decl(struct ctx *ctx,
 			siblings);
 
 		if (left->u.unary_expression.type != UNARY_STRING) {
-			_BT_LOGE_NODE(left,
+			_BT_COMP_LOGE_NODE(left,
 				"Unexpected unary expression type: type=%d",
 				left->u.unary_expression.type);
 			ret = -EINVAL;
 			goto error;
 		}
 
-		if (!strcmp(left->u.unary_expression.u.string, "byte_order")) {
+		if (strcmp(left->u.unary_expression.u.string, "byte_order") == 0) {
 			if (_IS_SET(&set, _FLOAT_BYTE_ORDER_SET)) {
-				_BT_LOGE_DUP_ATTR(left, "byte_order",
+				_BT_COMP_LOGE_DUP_ATTR(left, "byte_order",
 					"floating point number field class");
 				ret = -EPERM;
 				goto error;
@@ -2758,7 +2677,7 @@ int visit_floating_point_number_decl(struct ctx *ctx,
 
 			byte_order = get_real_byte_order(ctx, right);
 			if (byte_order == -1) {
-				_BT_LOGE_NODE(right,
+				_BT_COMP_LOGE_NODE(right,
 					"Invalid `byte_order` attribute in floating point number field class: "
 					"ret=%d", ret);
 				ret = -EINVAL;
@@ -2766,10 +2685,9 @@ int visit_floating_point_number_decl(struct ctx *ctx,
 			}
 
 			_SET(&set, _FLOAT_BYTE_ORDER_SET);
-		} else if (!strcmp(left->u.unary_expression.u.string,
-				"exp_dig")) {
+		} else if (strcmp(left->u.unary_expression.u.string, "exp_dig") == 0) {
 			if (_IS_SET(&set, _FLOAT_EXP_DIG_SET)) {
-				_BT_LOGE_DUP_ATTR(left, "exp_dig",
+				_BT_COMP_LOGE_DUP_ATTR(left, "exp_dig",
 					"floating point number field class");
 				ret = -EPERM;
 				goto error;
@@ -2777,7 +2695,7 @@ int visit_floating_point_number_decl(struct ctx *ctx,
 
 			if (right->u.unary_expression.type !=
 					UNARY_UNSIGNED_CONSTANT) {
-				_BT_LOGE_NODE(right,
+				_BT_COMP_LOGE_NODE(right,
 					"Invalid `exp_dig` attribute in floating point number field class: "
 					"expecting unsigned constant integer: "
 					"node-type=%d",
@@ -2788,10 +2706,9 @@ int visit_floating_point_number_decl(struct ctx *ctx,
 
 			exp_dig = right->u.unary_expression.u.unsigned_constant;
 			_SET(&set, _FLOAT_EXP_DIG_SET);
-		} else if (!strcmp(left->u.unary_expression.u.string,
-				"mant_dig")) {
+		} else if (strcmp(left->u.unary_expression.u.string, "mant_dig") == 0) {
 			if (_IS_SET(&set, _FLOAT_MANT_DIG_SET)) {
-				_BT_LOGE_DUP_ATTR(left, "mant_dig",
+				_BT_COMP_LOGE_DUP_ATTR(left, "mant_dig",
 					"floating point number field class");
 				ret = -EPERM;
 				goto error;
@@ -2799,7 +2716,7 @@ int visit_floating_point_number_decl(struct ctx *ctx,
 
 			if (right->u.unary_expression.type !=
 					UNARY_UNSIGNED_CONSTANT) {
-				_BT_LOGE_NODE(right,
+				_BT_COMP_LOGE_NODE(right,
 					"Invalid `mant_dig` attribute in floating point number field class: "
 					"expecting unsigned constant integer: "
 					"node-type=%d",
@@ -2811,10 +2728,9 @@ int visit_floating_point_number_decl(struct ctx *ctx,
 			mant_dig = right->u.unary_expression.u.
 				unsigned_constant;
 			_SET(&set, _FLOAT_MANT_DIG_SET);
-		} else if (!strcmp(left->u.unary_expression.u.string,
-				"align")) {
+		} else if (strcmp(left->u.unary_expression.u.string, "align") == 0) {
 			if (_IS_SET(&set, _FLOAT_ALIGN_SET)) {
-				_BT_LOGE_DUP_ATTR(left, "align",
+				_BT_COMP_LOGE_DUP_ATTR(left, "align",
 					"floating point number field class");
 				ret = -EPERM;
 				goto error;
@@ -2822,7 +2738,7 @@ int visit_floating_point_number_decl(struct ctx *ctx,
 
 			if (right->u.unary_expression.type !=
 					UNARY_UNSIGNED_CONSTANT) {
-				_BT_LOGE_NODE(right,
+				_BT_COMP_LOGE_NODE(right,
 					"Invalid `align` attribute in floating point number field class: "
 					"expecting unsigned constant integer: "
 					"node-type=%d",
@@ -2835,7 +2751,7 @@ int visit_floating_point_number_decl(struct ctx *ctx,
 				unsigned_constant;
 
 			if (!is_align_valid(alignment)) {
-				_BT_LOGE_NODE(right,
+				_BT_COMP_LOGE_NODE(right,
 					"Invalid `align` attribute in floating point number field class: "
 					"expecting power of two: "
 					"align=%" PRIu64, alignment);
@@ -2845,7 +2761,7 @@ int visit_floating_point_number_decl(struct ctx *ctx,
 
 			_SET(&set, _FLOAT_ALIGN_SET);
 		} else {
-			_BT_LOGW_NODE(left,
+			_BT_COMP_LOGW_NODE(left,
 				"Unknown attribute in floating point number field class: "
 				"attr-name=\"%s\"",
 				left->u.unary_expression.u.string);
@@ -2853,31 +2769,31 @@ int visit_floating_point_number_decl(struct ctx *ctx,
 	}
 
 	if (!_IS_SET(&set, _FLOAT_MANT_DIG_SET)) {
-		BT_LOGE_STR("Missing `mant_dig` attribute in floating point number field class.");
+		BT_COMP_LOGE_STR("Missing `mant_dig` attribute in floating point number field class.");
 		ret = -EPERM;
 		goto error;
 	}
 
 	if (!_IS_SET(&set, _FLOAT_EXP_DIG_SET)) {
-		BT_LOGE_STR("Missing `exp_dig` attribute in floating point number field class.");
+		BT_COMP_LOGE_STR("Missing `exp_dig` attribute in floating point number field class.");
 		ret = -EPERM;
 		goto error;
 	}
 
 	if (mant_dig != 24 && mant_dig != 53) {
-		BT_LOGE_STR("`mant_dig` attribute: expecting 24 or 53.");
+		BT_COMP_LOGE_STR("`mant_dig` attribute: expecting 24 or 53.");
 		ret = -EPERM;
 		goto error;
 	}
 
 	if (mant_dig == 24 && exp_dig != 8) {
-		BT_LOGE_STR("`exp_dig` attribute: expecting 8 because `mant_dig` is 24.");
+		BT_COMP_LOGE_STR("`exp_dig` attribute: expecting 8 because `mant_dig` is 24.");
 		ret = -EPERM;
 		goto error;
 	}
 
 	if (mant_dig == 53 && exp_dig != 11) {
-		BT_LOGE_STR("`exp_dig` attribute: expecting 11 because `mant_dig` is 53.");
+		BT_COMP_LOGE_STR("`exp_dig` attribute: expecting 11 because `mant_dig` is 53.");
 		ret = -EPERM;
 		goto error;
 	}
@@ -2927,25 +2843,25 @@ int visit_string_decl(struct ctx *ctx,
 			siblings);
 
 		if (left->u.unary_expression.type != UNARY_STRING) {
-			_BT_LOGE_NODE(left,
+			_BT_COMP_LOGE_NODE(left,
 				"Unexpected unary expression type: type=%d",
 				left->u.unary_expression.type);
 			ret = -EINVAL;
 			goto error;
 		}
 
-		if (!strcmp(left->u.unary_expression.u.string, "encoding")) {
+		if (strcmp(left->u.unary_expression.u.string, "encoding") == 0) {
 			char *s_right;
 
 			if (_IS_SET(&set, _STRING_ENCODING_SET)) {
-				_BT_LOGE_DUP_ATTR(left, "encoding",
+				_BT_COMP_LOGE_DUP_ATTR(left, "encoding",
 					"string field class");
 				ret = -EPERM;
 				goto error;
 			}
 
 			if (right->u.unary_expression.type != UNARY_STRING) {
-				_BT_LOGE_NODE(right,
+				_BT_COMP_LOGE_NODE(right,
 					"Invalid `encoding` attribute in string field class: "
 					"expecting unary string.");
 				ret = -EINVAL;
@@ -2955,23 +2871,23 @@ int visit_string_decl(struct ctx *ctx,
 			s_right = concatenate_unary_strings(
 				&expression->u.ctf_expression.right);
 			if (!s_right) {
-				_BT_LOGE_NODE(right,
+				_BT_COMP_LOGE_NODE(right,
 					"Unexpected unary expression for string field class's `encoding` attribute.");
 				ret = -EINVAL;
 				goto error;
 			}
 
-			if (!strcmp(s_right, "UTF8") ||
-					!strcmp(s_right, "utf8") ||
-					!strcmp(s_right, "utf-8") ||
-					!strcmp(s_right, "UTF-8") ||
-					!strcmp(s_right, "ASCII") ||
-					!strcmp(s_right, "ascii")) {
+			if (strcmp(s_right, "UTF8") == 0 ||
+					strcmp(s_right, "utf8") == 0 ||
+					strcmp(s_right, "utf-8") == 0 ||
+					strcmp(s_right, "UTF-8") == 0 ||
+					strcmp(s_right, "ASCII") == 0 ||
+					strcmp(s_right, "ascii") == 0) {
 				encoding = CTF_ENCODING_UTF8;
-			} else if (!strcmp(s_right, "none")) {
+			} else if (strcmp(s_right, "none") == 0) {
 				encoding = CTF_ENCODING_NONE;
 			} else {
-				_BT_LOGE_NODE(right,
+				_BT_COMP_LOGE_NODE(right,
 					"Invalid `encoding` attribute in string field class: "
 					"unknown encoding: encoding=\"%s\"",
 					s_right);
@@ -2983,7 +2899,7 @@ int visit_string_decl(struct ctx *ctx,
 			g_free(s_right);
 			_SET(&set, _STRING_ENCODING_SET);
 		} else {
-			_BT_LOGW_NODE(left,
+			_BT_COMP_LOGW_NODE(left,
 				"Unknown attribute in string field class: "
 				"attr-name=\"%s\"",
 				left->u.unary_expression.u.string);
@@ -3011,7 +2927,7 @@ int visit_field_class_specifier_list(struct ctx *ctx,
 	*decl = NULL;
 
 	if (ts_list->type != NODE_TYPE_SPECIFIER_LIST) {
-		_BT_LOGE_NODE(ts_list,
+		_BT_COMP_LOGE_NODE(ts_list,
 			"Unexpected node type: node-type=%d", ts_list->type);
 		ret = -EINVAL;
 		goto error;
@@ -3020,7 +2936,7 @@ int visit_field_class_specifier_list(struct ctx *ctx,
 	first = _BT_LIST_FIRST_ENTRY(&ts_list->u.field_class_specifier_list.head,
 		struct ctf_node, siblings);
 	if (first->type != NODE_TYPE_SPECIFIER) {
-		_BT_LOGE_NODE(first,
+		_BT_COMP_LOGE_NODE(first,
 			"Unexpected node type: node-type=%d", first->type);
 		ret = -EINVAL;
 		goto error;
@@ -3099,7 +3015,7 @@ int visit_field_class_specifier_list(struct ctx *ctx,
 	case TYPESPEC_ID_TYPE:
 		ret = visit_field_class_specifier(ctx, ts_list, decl);
 		if (ret) {
-			_BT_LOGE_NODE(first,
+			_BT_COMP_LOGE_NODE(first,
 				"Cannot visit field class specifier: ret=%d",
 				ret);
 			BT_ASSERT(!*decl);
@@ -3107,7 +3023,7 @@ int visit_field_class_specifier_list(struct ctx *ctx,
 		}
 		break;
 	default:
-		_BT_LOGE_NODE(first,
+		_BT_COMP_LOGE_NODE(first,
 			"Unexpected field class specifier type: node-type=%d",
 			first->u.field_class_specifier.type);
 		ret = -EINVAL;
@@ -3136,7 +3052,7 @@ int visit_event_decl_entry(struct ctx *ctx, struct ctf_node *node,
 		ret = visit_field_class_def(ctx, node->u.field_class_def.field_class_specifier_list,
 			&node->u.field_class_def.field_class_declarators);
 		if (ret) {
-			_BT_LOGE_NODE(node,
+			_BT_COMP_LOGE_NODE(node,
 				"Cannot add field class found in event class.");
 			goto error;
 		}
@@ -3145,7 +3061,7 @@ int visit_event_decl_entry(struct ctx *ctx, struct ctf_node *node,
 		ret = visit_field_class_alias(ctx, node->u.field_class_alias.target,
 			node->u.field_class_alias.alias);
 		if (ret) {
-			_BT_LOGE_NODE(node,
+			_BT_COMP_LOGE_NODE(node,
 				"Cannot add field class alias found in event class.");
 			goto error;
 		}
@@ -3154,34 +3070,35 @@ int visit_event_decl_entry(struct ctx *ctx, struct ctf_node *node,
 	{
 		left = concatenate_unary_strings(&node->u.ctf_expression.left);
 		if (!left) {
-			_BT_LOGE_NODE(node, "Cannot concatenate unary strings.");
+			_BT_COMP_LOGE_NODE(node, "Cannot concatenate unary strings.");
 			ret = -EINVAL;
 			goto error;
 		}
 
-		if (!strcmp(left, "name")) {
+		if (strcmp(left, "name") == 0) {
 			/* This is already known at this stage */
 			if (_IS_SET(set, _EVENT_NAME_SET)) {
-				_BT_LOGE_DUP_ATTR(node, "name", "event class");
+				_BT_COMP_LOGE_DUP_ATTR(node, "name", "event class");
 				ret = -EPERM;
 				goto error;
 			}
 
 			_SET(set, _EVENT_NAME_SET);
-		} else if (!strcmp(left, "id")) {
+		} else if (strcmp(left, "id") == 0) {
 			int64_t id = -1;
 
 			if (_IS_SET(set, _EVENT_ID_SET)) {
-				_BT_LOGE_DUP_ATTR(node, "id", "event class");
+				_BT_COMP_LOGE_DUP_ATTR(node, "id", "event class");
 				ret = -EPERM;
 				goto error;
 			}
 
-			ret = get_unary_unsigned(&node->u.ctf_expression.right,
+			ret = get_unary_unsigned(ctx,
+				&node->u.ctf_expression.right,
 				(uint64_t *) &id);
 			/* Only read "id" if get_unary_unsigned() succeeded. */
 			if (ret || (!ret && id < 0)) {
-				_BT_LOGE_NODE(node,
+				_BT_COMP_LOGE_NODE(node,
 					"Unexpected unary expression for event class's `id` attribute.");
 				ret = -EINVAL;
 				goto error;
@@ -3189,32 +3106,32 @@ int visit_event_decl_entry(struct ctx *ctx, struct ctf_node *node,
 
 			event_class->id = id;
 			_SET(set, _EVENT_ID_SET);
-		} else if (!strcmp(left, "stream_id")) {
+		} else if (strcmp(left, "stream_id") == 0) {
 			if (_IS_SET(set, _EVENT_STREAM_ID_SET)) {
-				_BT_LOGE_DUP_ATTR(node, "stream_id",
+				_BT_COMP_LOGE_DUP_ATTR(node, "stream_id",
 					"event class");
 				ret = -EPERM;
 				goto error;
 			}
 
-			ret = get_unary_unsigned(&node->u.ctf_expression.right,
-				stream_id);
+			ret = get_unary_unsigned(ctx,
+				&node->u.ctf_expression.right, stream_id);
 
 			/*
 			 * Only read "stream_id" if get_unary_unsigned()
 			 * succeeded.
 			 */
 			if (ret) {
-				_BT_LOGE_NODE(node,
+				_BT_COMP_LOGE_NODE(node,
 					"Unexpected unary expression for event class's `stream_id` attribute.");
 				ret = -EINVAL;
 				goto error;
 			}
 
 			_SET(set, _EVENT_STREAM_ID_SET);
-		} else if (!strcmp(left, "context")) {
+		} else if (strcmp(left, "context") == 0) {
 			if (_IS_SET(set, _EVENT_CONTEXT_SET)) {
-				_BT_LOGE_NODE(node,
+				_BT_COMP_LOGE_NODE(node,
 					"Duplicate `context` entry in event class.");
 				ret = -EPERM;
 				goto error;
@@ -3226,16 +3143,16 @@ int visit_event_decl_entry(struct ctx *ctx, struct ctf_node *node,
 					struct ctf_node, siblings),
 				&event_class->spec_context_fc);
 			if (ret) {
-				_BT_LOGE_NODE(node,
+				_BT_COMP_LOGE_NODE(node,
 					"Cannot create event class's context field class.");
 				goto error;
 			}
 
 			BT_ASSERT(event_class->spec_context_fc);
 			_SET(set, _EVENT_CONTEXT_SET);
-		} else if (!strcmp(left, "fields")) {
+		} else if (strcmp(left, "fields") == 0) {
 			if (_IS_SET(set, _EVENT_FIELDS_SET)) {
-				_BT_LOGE_NODE(node,
+				_BT_COMP_LOGE_NODE(node,
 					"Duplicate `fields` entry in event class.");
 				ret = -EPERM;
 				goto error;
@@ -3247,28 +3164,28 @@ int visit_event_decl_entry(struct ctx *ctx, struct ctf_node *node,
 					struct ctf_node, siblings),
 				&event_class->payload_fc);
 			if (ret) {
-				_BT_LOGE_NODE(node,
+				_BT_COMP_LOGE_NODE(node,
 					"Cannot create event class's payload field class.");
 				goto error;
 			}
 
 			BT_ASSERT(event_class->payload_fc);
 			_SET(set, _EVENT_FIELDS_SET);
-		} else if (!strcmp(left, "loglevel")) {
+		} else if (strcmp(left, "loglevel") == 0) {
 			uint64_t loglevel_value;
 			bt_event_class_log_level log_level = -1;
 
 			if (_IS_SET(set, _EVENT_LOG_LEVEL_SET)) {
-				_BT_LOGE_DUP_ATTR(node, "loglevel",
+				_BT_COMP_LOGE_DUP_ATTR(node, "loglevel",
 					"event class");
 				ret = -EPERM;
 				goto error;
 			}
 
-			ret = get_unary_unsigned(&node->u.ctf_expression.right,
-				&loglevel_value);
+			ret = get_unary_unsigned(ctx,
+				&node->u.ctf_expression.right, &loglevel_value);
 			if (ret) {
-				_BT_LOGE_NODE(node,
+				_BT_COMP_LOGE_NODE(node,
 					"Unexpected unary expression for event class's `loglevel` attribute.");
 				ret = -EINVAL;
 				goto error;
@@ -3321,7 +3238,7 @@ int visit_event_decl_entry(struct ctx *ctx, struct ctf_node *node,
 				log_level = BT_EVENT_CLASS_LOG_LEVEL_DEBUG;
 				break;
 			default:
-				_BT_LOGW_NODE(node, "Not setting event class's log level because its value is unknown: "
+				_BT_COMP_LOGW_NODE(node, "Not setting event class's log level because its value is unknown: "
 					"log-level=%" PRIu64, loglevel_value);
 			}
 
@@ -3330,11 +3247,11 @@ int visit_event_decl_entry(struct ctx *ctx, struct ctf_node *node,
 			}
 
 			_SET(set, _EVENT_LOG_LEVEL_SET);
-		} else if (!strcmp(left, "model.emf.uri")) {
+		} else if (strcmp(left, "model.emf.uri") == 0) {
 			char *right;
 
 			if (_IS_SET(set, _EVENT_MODEL_EMF_URI_SET)) {
-				_BT_LOGE_DUP_ATTR(node, "model.emf.uri",
+				_BT_COMP_LOGE_DUP_ATTR(node, "model.emf.uri",
 					"event class");
 				ret = -EPERM;
 				goto error;
@@ -3343,14 +3260,14 @@ int visit_event_decl_entry(struct ctx *ctx, struct ctf_node *node,
 			right = concatenate_unary_strings(
 				&node->u.ctf_expression.right);
 			if (!right) {
-				_BT_LOGE_NODE(node,
+				_BT_COMP_LOGE_NODE(node,
 					"Unexpected unary expression for event class's `model.emf.uri` attribute.");
 				ret = -EINVAL;
 				goto error;
 			}
 
 			if (strlen(right) == 0) {
-				_BT_LOGW_NODE(node,
+				_BT_COMP_LOGW_NODE(node,
 					"Not setting event class's EMF URI because it's empty.");
 			} else {
 				g_string_assign(event_class->emf_uri,
@@ -3360,7 +3277,7 @@ int visit_event_decl_entry(struct ctx *ctx, struct ctf_node *node,
 			g_free(right);
 			_SET(set, _EVENT_MODEL_EMF_URI_SET);
 		} else {
-			_BT_LOGW_NODE(node,
+			_BT_COMP_LOGW_NODE(node,
 				"Unknown attribute in event class: "
 				"attr-name=\"%s\"", left);
 		}
@@ -3377,9 +3294,7 @@ int visit_event_decl_entry(struct ctx *ctx, struct ctf_node *node,
 	goto end;
 
 error:
-	if (left) {
-		g_free(left);
-	}
+	g_free(left);
 
 end:
 	return ret;
@@ -3400,16 +3315,16 @@ char *get_event_decl_name(struct ctx *ctx, struct ctf_node *node)
 
 		left = concatenate_unary_strings(&iter->u.ctf_expression.left);
 		if (!left) {
-			_BT_LOGE_NODE(iter,
+			_BT_COMP_LOGE_NODE(iter,
 				"Cannot concatenate unary strings.");
 			goto error;
 		}
 
-		if (!strcmp(left, "name")) {
+		if (strcmp(left, "name") == 0) {
 			name = concatenate_unary_strings(
 				&iter->u.ctf_expression.right);
 			if (!name) {
-				_BT_LOGE_NODE(iter,
+				_BT_COMP_LOGE_NODE(iter,
 					"Unexpected unary expression for event class's `name` attribute.");
 				goto error;
 			}
@@ -3450,7 +3365,7 @@ int visit_event_decl(struct ctx *ctx, struct ctf_node *node)
 	node->visited = TRUE;
 	event_name = get_event_decl_name(ctx, node);
 	if (!event_name) {
-		_BT_LOGE_NODE(node,
+		_BT_COMP_LOGE_NODE(node,
 			"Missing `name` attribute in event class.");
 		ret = -EPERM;
 		goto error;
@@ -3466,7 +3381,7 @@ int visit_event_decl(struct ctx *ctx, struct ctf_node *node)
 		ret = visit_event_decl_entry(ctx, iter, event_class,
 			&stream_id, &set);
 		if (ret) {
-			_BT_LOGE_NODE(iter, "Cannot visit event class's entry: "
+			_BT_COMP_LOGE_NODE(iter, "Cannot visit event class's entry: "
 				"ret=%d", ret);
 			goto error;
 		}
@@ -3493,7 +3408,7 @@ int visit_event_decl(struct ctx *ctx, struct ctf_node *node)
 			stream_id = stream_class->id;
 			break;
 		default:
-			_BT_LOGE_NODE(node,
+			_BT_COMP_LOGE_NODE(node,
 				"Missing `stream_id` attribute in event class.");
 			ret = -EPERM;
 			goto error;
@@ -3505,7 +3420,7 @@ int visit_event_decl(struct ctx *ctx, struct ctf_node *node)
 		stream_class = ctf_trace_class_borrow_stream_class_by_id(
 			ctx->ctf_tc, stream_id);
 		if (!stream_class) {
-			_BT_LOGE_NODE(node,
+			_BT_COMP_LOGE_NODE(node,
 				"Cannot find stream class at this point: "
 				"id=%" PRId64, stream_id);
 			ret = -EINVAL;
@@ -3518,7 +3433,7 @@ int visit_event_decl(struct ctx *ctx, struct ctf_node *node)
 	if (!_IS_SET(&set, _EVENT_ID_SET)) {
 		/* Allow only one event without ID per stream */
 		if (stream_class->event_classes->len != 0) {
-			_BT_LOGE_NODE(node,
+			_BT_COMP_LOGE_NODE(node,
 				"Missing `id` attribute in event class.");
 			ret = -EPERM;
 			goto error;
@@ -3530,7 +3445,7 @@ int visit_event_decl(struct ctx *ctx, struct ctf_node *node)
 
 	if (ctf_stream_class_borrow_event_class_by_id(stream_class,
 			event_class->id)) {
-		_BT_LOGE_NODE(node,
+		_BT_COMP_LOGE_NODE(node,
 			"Duplicate event class (same ID) in the same stream class: "
 			"id=%" PRId64, event_class->id);
 		ret = -EEXIST;
@@ -3554,9 +3469,7 @@ end:
 		ctx_pop_scope(ctx);
 	}
 
-	if (event_name) {
-		g_free(event_name);
-	}
+	g_free(event_name);
 
 	return ret;
 }
@@ -3613,7 +3526,7 @@ int auto_map_field_to_trace_clock_class(struct ctx *ctx,
 		 * Timestamp field not mapped to a clock class and there's more
 		 * than one clock class in the trace: this is an error.
 		 */
-		BT_LOGE_STR("Timestamp field found with no mapped clock class, "
+		BT_COMP_LOGE_STR("Timestamp field found with no mapped clock class, "
 			"but there's more than one clock class in the trace at this point.");
 		ret = -1;
 		goto end;
@@ -3665,7 +3578,7 @@ int auto_map_fields_to_trace_clock_class(struct ctx *ctx,
 			ret = auto_map_field_to_trace_clock_class(ctx,
 				named_fc->fc);
 			if (ret) {
-				BT_LOGE("Cannot automatically map field to trace's clock class: "
+				BT_COMP_LOGE("Cannot automatically map field to trace's clock class: "
 					"field-name=\"%s\"", field_name);
 				goto end;
 			}
@@ -3674,7 +3587,7 @@ int auto_map_fields_to_trace_clock_class(struct ctx *ctx,
 		ret = auto_map_fields_to_trace_clock_class(ctx, named_fc->fc,
 			field_name);
 		if (ret) {
-			BT_LOGE("Cannot automatically map structure or variant field class's fields to trace's clock class: "
+			BT_COMP_LOGE("Cannot automatically map structure or variant field class's fields to trace's clock class: "
 				"field-name=\"%s\", root-field-name=\"%s\"",
 				field_name, named_fc->name->str);
 			goto end;
@@ -3697,7 +3610,7 @@ int visit_stream_decl_entry(struct ctx *ctx, struct ctf_node *node,
 		ret = visit_field_class_def(ctx, node->u.field_class_def.field_class_specifier_list,
 			&node->u.field_class_def.field_class_declarators);
 		if (ret) {
-			_BT_LOGE_NODE(node,
+			_BT_COMP_LOGE_NODE(node,
 				"Cannot add field class found in stream class.");
 			goto error;
 		}
@@ -3706,7 +3619,7 @@ int visit_stream_decl_entry(struct ctx *ctx, struct ctf_node *node,
 		ret = visit_field_class_alias(ctx, node->u.field_class_alias.target,
 			node->u.field_class_alias.alias);
 		if (ret) {
-			_BT_LOGE_NODE(node,
+			_BT_COMP_LOGE_NODE(node,
 				"Cannot add field class alias found in stream class.");
 			goto error;
 		}
@@ -3715,27 +3628,28 @@ int visit_stream_decl_entry(struct ctx *ctx, struct ctf_node *node,
 	{
 		left = concatenate_unary_strings(&node->u.ctf_expression.left);
 		if (!left) {
-			_BT_LOGE_NODE(node, "Cannot concatenate unary strings.");
+			_BT_COMP_LOGE_NODE(node, "Cannot concatenate unary strings.");
 			ret = -EINVAL;
 			goto error;
 		}
 
-		if (!strcmp(left, "id")) {
+		if (strcmp(left, "id") == 0) {
 			int64_t id;
 
 			if (_IS_SET(set, _STREAM_ID_SET)) {
-				_BT_LOGE_DUP_ATTR(node, "id",
+				_BT_COMP_LOGE_DUP_ATTR(node, "id",
 					"stream declaration");
 				ret = -EPERM;
 				goto error;
 			}
 
-			ret = get_unary_unsigned(&node->u.ctf_expression.right,
+			ret = get_unary_unsigned(ctx,
+				&node->u.ctf_expression.right,
 				(uint64_t *) &id);
 
 			/* Only read "id" if get_unary_unsigned() succeeded. */
 			if (ret || (!ret && id < 0)) {
-				_BT_LOGE_NODE(node,
+				_BT_COMP_LOGE_NODE(node,
 					"Unexpected unary expression for stream class's `id` attribute.");
 				ret = -EINVAL;
 				goto error;
@@ -3743,7 +3657,7 @@ int visit_stream_decl_entry(struct ctx *ctx, struct ctf_node *node,
 
 			if (ctf_trace_class_borrow_stream_class_by_id(
 					ctx->ctf_tc, id)) {
-				_BT_LOGE_NODE(node,
+				_BT_COMP_LOGE_NODE(node,
 					"Duplicate stream class (same ID): id=%" PRId64,
 					id);
 				ret = -EEXIST;
@@ -3752,9 +3666,9 @@ int visit_stream_decl_entry(struct ctx *ctx, struct ctf_node *node,
 
 			stream_class->id = id;
 			_SET(set, _STREAM_ID_SET);
-		} else if (!strcmp(left, "event.header")) {
+		} else if (strcmp(left, "event.header") == 0) {
 			if (_IS_SET(set, _STREAM_EVENT_HEADER_SET)) {
-				_BT_LOGE_NODE(node,
+				_BT_COMP_LOGE_NODE(node,
 					"Duplicate `event.header` entry in stream class.");
 				ret = -EPERM;
 				goto error;
@@ -3766,7 +3680,7 @@ int visit_stream_decl_entry(struct ctx *ctx, struct ctf_node *node,
 					struct ctf_node, siblings),
 				&stream_class->event_header_fc);
 			if (ret) {
-				_BT_LOGE_NODE(node,
+				_BT_COMP_LOGE_NODE(node,
 					"Cannot create stream class's event header field class.");
 				goto error;
 			}
@@ -3775,15 +3689,15 @@ int visit_stream_decl_entry(struct ctx *ctx, struct ctf_node *node,
 			ret = auto_map_fields_to_trace_clock_class(ctx,
 				stream_class->event_header_fc, "timestamp");
 			if (ret) {
-				_BT_LOGE_NODE(node,
+				_BT_COMP_LOGE_NODE(node,
 					"Cannot automatically map specific event header field class fields named `timestamp` to trace's clock class.");
 				goto error;
 			}
 
 			_SET(set, _STREAM_EVENT_HEADER_SET);
-		} else if (!strcmp(left, "event.context")) {
+		} else if (strcmp(left, "event.context") == 0) {
 			if (_IS_SET(set, _STREAM_EVENT_CONTEXT_SET)) {
-				_BT_LOGE_NODE(node,
+				_BT_COMP_LOGE_NODE(node,
 					"Duplicate `event.context` entry in stream class.");
 				ret = -EPERM;
 				goto error;
@@ -3795,16 +3709,16 @@ int visit_stream_decl_entry(struct ctx *ctx, struct ctf_node *node,
 					struct ctf_node, siblings),
 				&stream_class->event_common_context_fc);
 			if (ret) {
-				_BT_LOGE_NODE(node,
+				_BT_COMP_LOGE_NODE(node,
 					"Cannot create stream class's event context field class.");
 				goto error;
 			}
 
 			BT_ASSERT(stream_class->event_common_context_fc);
 			_SET(set, _STREAM_EVENT_CONTEXT_SET);
-		} else if (!strcmp(left, "packet.context")) {
+		} else if (strcmp(left, "packet.context") == 0) {
 			if (_IS_SET(set, _STREAM_PACKET_CONTEXT_SET)) {
-				_BT_LOGE_NODE(node,
+				_BT_COMP_LOGE_NODE(node,
 					"Duplicate `packet.context` entry in stream class.");
 				ret = -EPERM;
 				goto error;
@@ -3816,7 +3730,7 @@ int visit_stream_decl_entry(struct ctx *ctx, struct ctf_node *node,
 					struct ctf_node, siblings),
 				&stream_class->packet_context_fc);
 			if (ret) {
-				_BT_LOGE_NODE(node,
+				_BT_COMP_LOGE_NODE(node,
 					"Cannot create stream class's packet context field class.");
 				goto error;
 			}
@@ -3826,7 +3740,7 @@ int visit_stream_decl_entry(struct ctx *ctx, struct ctf_node *node,
 				stream_class->packet_context_fc,
 				"timestamp_begin");
 			if (ret) {
-				_BT_LOGE_NODE(node,
+				_BT_COMP_LOGE_NODE(node,
 					"Cannot automatically map specific packet context field class fields named `timestamp_begin` to trace's clock class.");
 				goto error;
 			}
@@ -3835,14 +3749,14 @@ int visit_stream_decl_entry(struct ctx *ctx, struct ctf_node *node,
 				stream_class->packet_context_fc,
 				"timestamp_end");
 			if (ret) {
-				_BT_LOGE_NODE(node,
+				_BT_COMP_LOGE_NODE(node,
 					"Cannot automatically map specific packet context field class fields named `timestamp_end` to trace's clock class.");
 				goto error;
 			}
 
 			_SET(set, _STREAM_PACKET_CONTEXT_SET);
 		} else {
-			_BT_LOGW_NODE(node,
+			_BT_COMP_LOGW_NODE(node,
 				"Unknown attribute in stream class: "
 				"attr-name=\"%s\"", left);
 		}
@@ -3885,7 +3799,7 @@ int visit_stream_decl(struct ctx *ctx, struct ctf_node *node)
 	bt_list_for_each_entry(iter, decl_list, siblings) {
 		ret = visit_stream_decl_entry(ctx, iter, stream_class, &set);
 		if (ret) {
-			_BT_LOGE_NODE(iter,
+			_BT_COMP_LOGE_NODE(iter,
 				"Cannot visit stream class's entry: "
 				"ret=%d", ret);
 			ctx_pop_scope(ctx);
@@ -3900,7 +3814,7 @@ int visit_stream_decl(struct ctx *ctx, struct ctf_node *node)
 		struct ctf_named_field_class *named_fc = NULL;
 
 		if (!ctx->ctf_tc->packet_header_fc) {
-			_BT_LOGE_NODE(node,
+			_BT_COMP_LOGE_NODE(node,
 				"Stream class has a `id` attribute, "
 				"but trace has no packet header field class.");
 			goto error;
@@ -3909,7 +3823,7 @@ int visit_stream_decl(struct ctx *ctx, struct ctf_node *node)
 		named_fc = ctf_field_class_struct_borrow_member_by_name(
 			(void *) ctx->ctf_tc->packet_header_fc, "stream_id");
 		if (!named_fc) {
-			_BT_LOGE_NODE(node,
+			_BT_COMP_LOGE_NODE(node,
 				"Stream class has a `id` attribute, "
 				"but trace's packet header field class has no `stream_id` field.");
 			goto error;
@@ -3917,7 +3831,7 @@ int visit_stream_decl(struct ctx *ctx, struct ctf_node *node)
 
 		if (named_fc->fc->type != CTF_FIELD_CLASS_TYPE_INT &&
 				named_fc->fc->type != CTF_FIELD_CLASS_TYPE_ENUM) {
-			_BT_LOGE_NODE(node,
+			_BT_COMP_LOGE_NODE(node,
 				"Stream class has a `id` attribute, "
 				"but trace's packet header field class's `stream_id` field is not an integer field class.");
 			goto error;
@@ -3925,7 +3839,7 @@ int visit_stream_decl(struct ctx *ctx, struct ctf_node *node)
 	} else {
 		/* Allow only _one_ ID-less stream */
 		if (ctx->ctf_tc->stream_classes->len != 0) {
-			_BT_LOGE_NODE(node,
+			_BT_COMP_LOGE_NODE(node,
 				"Missing `id` attribute in stream class as there's more than one stream class in the trace.");
 			ret = -EPERM;
 			goto error;
@@ -3941,7 +3855,7 @@ int visit_stream_decl(struct ctx *ctx, struct ctf_node *node)
 	 */
 	if (ctf_trace_class_borrow_stream_class_by_id(ctx->ctf_tc,
 			stream_class->id)) {
-		_BT_LOGE_NODE(node,
+		_BT_COMP_LOGE_NODE(node,
 			"Duplicate stream class (same ID): id=%" PRId64,
 			stream_class->id);
 		ret = -EINVAL;
@@ -3972,7 +3886,7 @@ int visit_trace_decl_entry(struct ctx *ctx, struct ctf_node *node, int *set)
 		ret = visit_field_class_def(ctx, node->u.field_class_def.field_class_specifier_list,
 			&node->u.field_class_def.field_class_declarators);
 		if (ret) {
-			_BT_LOGE_NODE(node,
+			_BT_COMP_LOGE_NODE(node,
 				"Cannot add field class found in trace (`trace` block).");
 			goto error;
 		}
@@ -3981,7 +3895,7 @@ int visit_trace_decl_entry(struct ctx *ctx, struct ctf_node *node, int *set)
 		ret = visit_field_class_alias(ctx, node->u.field_class_alias.target,
 			node->u.field_class_alias.alias);
 		if (ret) {
-			_BT_LOGE_NODE(node,
+			_BT_COMP_LOGE_NODE(node,
 				"Cannot add field class alias found in trace (`trace` block).");
 			goto error;
 		}
@@ -3990,80 +3904,81 @@ int visit_trace_decl_entry(struct ctx *ctx, struct ctf_node *node, int *set)
 	{
 		left = concatenate_unary_strings(&node->u.ctf_expression.left);
 		if (!left) {
-			_BT_LOGE_NODE(node, "Cannot concatenate unary strings.");
+			_BT_COMP_LOGE_NODE(node, "Cannot concatenate unary strings.");
 			ret = -EINVAL;
 			goto error;
 		}
 
-		if (!strcmp(left, "major")) {
+		if (strcmp(left, "major") == 0) {
 			if (_IS_SET(set, _TRACE_MAJOR_SET)) {
-				_BT_LOGE_DUP_ATTR(node, "major", "trace");
+				_BT_COMP_LOGE_DUP_ATTR(node, "major", "trace");
 				ret = -EPERM;
 				goto error;
 			}
 
-			ret = get_unary_unsigned(&node->u.ctf_expression.right,
-				&val);
+			ret = get_unary_unsigned(ctx,
+				&node->u.ctf_expression.right, &val);
 			if (ret) {
-				_BT_LOGE_NODE(node,
+				_BT_COMP_LOGE_NODE(node,
 					"Unexpected unary expression for trace's `major` attribute.");
 				ret = -EINVAL;
 				goto error;
 			}
 
 			if (val != 1) {
-				_BT_LOGE_NODE(node,
+				_BT_COMP_LOGE_NODE(node,
 					"Invalid trace's `minor` attribute: expecting 1.");
 				goto error;
 			}
 
 			ctx->ctf_tc->major = val;
 			_SET(set, _TRACE_MAJOR_SET);
-		} else if (!strcmp(left, "minor")) {
+		} else if (strcmp(left, "minor") == 0) {
 			if (_IS_SET(set, _TRACE_MINOR_SET)) {
-				_BT_LOGE_DUP_ATTR(node, "minor", "trace");
+				_BT_COMP_LOGE_DUP_ATTR(node, "minor", "trace");
 				ret = -EPERM;
 				goto error;
 			}
 
-			ret = get_unary_unsigned(&node->u.ctf_expression.right,
-				&val);
+			ret = get_unary_unsigned(ctx,
+				&node->u.ctf_expression.right, &val);
 			if (ret) {
-				_BT_LOGE_NODE(node,
+				_BT_COMP_LOGE_NODE(node,
 					"Unexpected unary expression for trace's `minor` attribute.");
 				ret = -EINVAL;
 				goto error;
 			}
 
 			if (val != 8) {
-				_BT_LOGE_NODE(node,
+				_BT_COMP_LOGE_NODE(node,
 					"Invalid trace's `minor` attribute: expecting 8.");
 				goto error;
 			}
 
 			ctx->ctf_tc->minor = val;
 			_SET(set, _TRACE_MINOR_SET);
-		} else if (!strcmp(left, "uuid")) {
+		} else if (strcmp(left, "uuid") == 0) {
 			if (_IS_SET(set, _TRACE_UUID_SET)) {
-				_BT_LOGE_DUP_ATTR(node, "uuid", "trace");
+				_BT_COMP_LOGE_DUP_ATTR(node, "uuid", "trace");
 				ret = -EPERM;
 				goto error;
 			}
 
-			ret = get_unary_uuid(&node->u.ctf_expression.right,
+			ret = get_unary_uuid(ctx,
+				&node->u.ctf_expression.right,
 				ctx->ctf_tc->uuid);
 			if (ret) {
-				_BT_LOGE_NODE(node,
+				_BT_COMP_LOGE_NODE(node,
 					"Invalid trace's `uuid` attribute.");
 				goto error;
 			}
 
 			ctx->ctf_tc->is_uuid_set = true;
 			_SET(set, _TRACE_UUID_SET);
-		} else if (!strcmp(left, "byte_order")) {
+		} else if (strcmp(left, "byte_order") == 0) {
 			/* Default byte order is already known at this stage */
 			if (_IS_SET(set, _TRACE_BYTE_ORDER_SET)) {
-				_BT_LOGE_DUP_ATTR(node, "byte_order",
+				_BT_COMP_LOGE_DUP_ATTR(node, "byte_order",
 					"trace");
 				ret = -EPERM;
 				goto error;
@@ -4071,9 +3986,9 @@ int visit_trace_decl_entry(struct ctx *ctx, struct ctf_node *node, int *set)
 
 			BT_ASSERT(ctx->ctf_tc->default_byte_order != -1);
 			_SET(set, _TRACE_BYTE_ORDER_SET);
-		} else if (!strcmp(left, "packet.header")) {
+		} else if (strcmp(left, "packet.header") == 0) {
 			if (_IS_SET(set, _TRACE_PACKET_HEADER_SET)) {
-				_BT_LOGE_NODE(node,
+				_BT_COMP_LOGE_NODE(node,
 					"Duplicate `packet.header` entry in trace.");
 				ret = -EPERM;
 				goto error;
@@ -4085,7 +4000,7 @@ int visit_trace_decl_entry(struct ctx *ctx, struct ctf_node *node, int *set)
 					struct ctf_node, siblings),
 				&ctx->ctf_tc->packet_header_fc);
 			if (ret) {
-				_BT_LOGE_NODE(node,
+				_BT_COMP_LOGE_NODE(node,
 					"Cannot create trace's packet header field class.");
 				goto error;
 			}
@@ -4093,7 +4008,7 @@ int visit_trace_decl_entry(struct ctx *ctx, struct ctf_node *node, int *set)
 			BT_ASSERT(ctx->ctf_tc->packet_header_fc);
 			_SET(set, _TRACE_PACKET_HEADER_SET);
 		} else {
-			_BT_LOGW_NODE(node,
+			_BT_COMP_LOGW_NODE(node,
 				"Unknown attribute in stream class: "
 				"attr-name=\"%s\"", left);
 		}
@@ -4103,7 +4018,7 @@ int visit_trace_decl_entry(struct ctx *ctx, struct ctf_node *node, int *set)
 		break;
 	}
 	default:
-		_BT_LOGE_NODE(node, "Unknown expression in trace.");
+		_BT_COMP_LOGE_NODE(node, "Unknown expression in trace.");
 		ret = -EINVAL;
 		goto error;
 	}
@@ -4130,7 +4045,7 @@ int visit_trace_decl(struct ctx *ctx, struct ctf_node *node)
 	node->visited = TRUE;
 
 	if (ctx->is_trace_visited) {
-		_BT_LOGE_NODE(node, "Duplicate trace (`trace` block).");
+		_BT_COMP_LOGE_NODE(node, "Duplicate trace (`trace` block).");
 		ret = -EEXIST;
 		goto error;
 	}
@@ -4140,7 +4055,7 @@ int visit_trace_decl(struct ctx *ctx, struct ctf_node *node)
 	bt_list_for_each_entry(iter, decl_list, siblings) {
 		ret = visit_trace_decl_entry(ctx, iter, &set);
 		if (ret) {
-			_BT_LOGE_NODE(iter, "Cannot visit trace's entry (`trace` block): "
+			_BT_COMP_LOGE_NODE(iter, "Cannot visit trace's entry (`trace` block): "
 				"ret=%d", ret);
 			ctx_pop_scope(ctx);
 			goto error;
@@ -4150,21 +4065,21 @@ int visit_trace_decl(struct ctx *ctx, struct ctf_node *node)
 	ctx_pop_scope(ctx);
 
 	if (!_IS_SET(&set, _TRACE_MAJOR_SET)) {
-		_BT_LOGE_NODE(node,
+		_BT_COMP_LOGE_NODE(node,
 			"Missing `major` attribute in trace (`trace` block).");
 		ret = -EPERM;
 		goto error;
 	}
 
 	if (!_IS_SET(&set, _TRACE_MINOR_SET)) {
-		_BT_LOGE_NODE(node,
+		_BT_COMP_LOGE_NODE(node,
 			"Missing `minor` attribute in trace (`trace` block).");
 		ret = -EPERM;
 		goto error;
 	}
 
 	if (!_IS_SET(&set, _TRACE_BYTE_ORDER_SET)) {
-		_BT_LOGE_NODE(node,
+		_BT_COMP_LOGE_NODE(node,
 			"Missing `byte_order` attribute in trace (`trace` block).");
 		ret = -EPERM;
 		goto error;
@@ -4198,7 +4113,7 @@ int visit_env(struct ctx *ctx, struct ctf_node *node)
 			&entry_node->u.ctf_expression.right;
 
 		if (entry_node->type != NODE_CTF_EXPRESSION) {
-			_BT_LOGE_NODE(entry_node,
+			_BT_COMP_LOGE_NODE(entry_node,
 				"Wrong expression in environment entry: "
 				"node-type=%d", entry_node->type);
 			ret = -EPERM;
@@ -4208,7 +4123,7 @@ int visit_env(struct ctx *ctx, struct ctf_node *node)
 		left = concatenate_unary_strings(
 			&entry_node->u.ctf_expression.left);
 		if (!left) {
-			_BT_LOGE_NODE(entry_node,
+			_BT_COMP_LOGE_NODE(entry_node,
 				"Cannot get environment entry's name.");
 			ret = -EINVAL;
 			goto error;
@@ -4218,7 +4133,7 @@ int visit_env(struct ctx *ctx, struct ctf_node *node)
 			char *right = concatenate_unary_strings(right_head);
 
 			if (!right) {
-				_BT_LOGE_NODE(entry_node,
+				_BT_COMP_LOGE_NODE(entry_node,
 					"Unexpected unary expression for environment entry's value: "
 					"name=\"%s\"", left);
 				ret = -EINVAL;
@@ -4227,7 +4142,7 @@ int visit_env(struct ctx *ctx, struct ctf_node *node)
 
 			if (strcmp(left, "tracer_name") == 0) {
 				if (strncmp(right, "lttng", 5) == 0) {
-					BT_LOGI("Detected LTTng trace from `%s` environment value: "
+					BT_COMP_LOGI("Detected LTTng trace from `%s` environment value: "
 						"tracer-name=\"%s\"",
 						left, right);
 					ctx->is_lttng = true;
@@ -4243,13 +4158,13 @@ int visit_env(struct ctx *ctx, struct ctf_node *node)
 			int64_t v;
 
 			if (is_unary_unsigned(right_head)) {
-				ret = get_unary_unsigned(right_head,
+				ret = get_unary_unsigned(ctx, right_head,
 					(uint64_t *) &v);
 			} else {
 				ret = get_unary_signed(right_head, &v);
 			}
 			if (ret) {
-				_BT_LOGE_NODE(entry_node,
+				_BT_COMP_LOGE_NODE(entry_node,
 					"Unexpected unary expression for environment entry's value: "
 					"name=\"%s\"", left);
 				ret = -EINVAL;
@@ -4260,7 +4175,7 @@ int visit_env(struct ctx *ctx, struct ctf_node *node)
 				left, CTF_TRACE_CLASS_ENV_ENTRY_TYPE_INT,
 				NULL, v);
 		} else {
-			_BT_LOGW_NODE(entry_node,
+			_BT_COMP_LOGW_NODE(entry_node,
 				"Environment entry has unknown type: "
 				"name=\"%s\"", left);
 		}
@@ -4293,17 +4208,17 @@ int set_trace_byte_order(struct ctx *ctx, struct ctf_node *trace_node)
 			left = concatenate_unary_strings(
 				&node->u.ctf_expression.left);
 			if (!left) {
-				_BT_LOGE_NODE(node,
+				_BT_COMP_LOGE_NODE(node,
 					"Cannot concatenate unary strings.");
 				ret = -EINVAL;
 				goto error;
 			}
 
-			if (!strcmp(left, "byte_order")) {
+			if (strcmp(left, "byte_order") == 0) {
 				enum ctf_byte_order bo;
 
 				if (_IS_SET(&set, _TRACE_BYTE_ORDER_SET)) {
-					_BT_LOGE_DUP_ATTR(node, "byte_order",
+					_BT_COMP_LOGE_DUP_ATTR(node, "byte_order",
 						"trace");
 					ret = -EPERM;
 					goto error;
@@ -4313,15 +4228,16 @@ int set_trace_byte_order(struct ctx *ctx, struct ctf_node *trace_node)
 				right_node = _BT_LIST_FIRST_ENTRY(
 					&node->u.ctf_expression.right,
 					struct ctf_node, siblings);
-				bo = byte_order_from_unary_expr(right_node);
+				bo = byte_order_from_unary_expr(ctx,
+					right_node);
 				if (bo == -1) {
-					_BT_LOGE_NODE(node,
+					_BT_COMP_LOGE_NODE(node,
 						"Invalid `byte_order` attribute in trace (`trace` block): "
 						"expecting `le`, `be`, or `network`.");
 					ret = -EINVAL;
 					goto error;
 				} else if (bo == CTF_BYTE_ORDER_DEFAULT) {
-					_BT_LOGE_NODE(node,
+					_BT_COMP_LOGE_NODE(node,
 						"Invalid `byte_order` attribute in trace (`trace` block): "
 						"cannot be set to `native` here.");
 					ret = -EPERM;
@@ -4337,7 +4253,7 @@ int set_trace_byte_order(struct ctx *ctx, struct ctf_node *trace_node)
 	}
 
 	if (!_IS_SET(&set, _TRACE_BYTE_ORDER_SET)) {
-		_BT_LOGE_NODE(trace_node,
+		_BT_COMP_LOGE_NODE(trace_node,
 			"Missing `byte_order` attribute in trace (`trace` block).");
 		ret = -EINVAL;
 		goto error;
@@ -4359,7 +4275,7 @@ int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node,
 	char *left = NULL;
 
 	if (entry_node->type != NODE_CTF_EXPRESSION) {
-		_BT_LOGE_NODE(entry_node,
+		_BT_COMP_LOGE_NODE(entry_node,
 			"Unexpected node type: node-type=%d",
 			entry_node->type);
 		ret = -EPERM;
@@ -4368,16 +4284,16 @@ int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node,
 
 	left = concatenate_unary_strings(&entry_node->u.ctf_expression.left);
 	if (!left) {
-		_BT_LOGE_NODE(entry_node, "Cannot concatenate unary strings.");
+		_BT_COMP_LOGE_NODE(entry_node, "Cannot concatenate unary strings.");
 		ret = -EINVAL;
 		goto error;
 	}
 
-	if (!strcmp(left, "name")) {
+	if (strcmp(left, "name") == 0) {
 		char *right;
 
 		if (_IS_SET(set, _CLOCK_NAME_SET)) {
-			_BT_LOGE_DUP_ATTR(entry_node, "name", "clock class");
+			_BT_COMP_LOGE_DUP_ATTR(entry_node, "name", "clock class");
 			ret = -EPERM;
 			goto error;
 		}
@@ -4385,7 +4301,7 @@ int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node,
 		right = concatenate_unary_strings(
 			&entry_node->u.ctf_expression.right);
 		if (!right) {
-			_BT_LOGE_NODE(entry_node,
+			_BT_COMP_LOGE_NODE(entry_node,
 				"Unexpected unary expression for clock class's `name` attribute.");
 			ret = -EINVAL;
 			goto error;
@@ -4394,30 +4310,31 @@ int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node,
 		g_string_assign(clock->name, right);
 		g_free(right);
 		_SET(set, _CLOCK_NAME_SET);
-	} else if (!strcmp(left, "uuid")) {
-		uint8_t uuid[BABELTRACE_UUID_LEN];
+	} else if (strcmp(left, "uuid") == 0) {
+		bt_uuid_t uuid;
 
 		if (_IS_SET(set, _CLOCK_UUID_SET)) {
-			_BT_LOGE_DUP_ATTR(entry_node, "uuid", "clock class");
+			_BT_COMP_LOGE_DUP_ATTR(entry_node, "uuid", "clock class");
 			ret = -EPERM;
 			goto error;
 		}
 
-		ret = get_unary_uuid(&entry_node->u.ctf_expression.right, uuid);
+		ret = get_unary_uuid(ctx, &entry_node->u.ctf_expression.right,
+			uuid);
 		if (ret) {
-			_BT_LOGE_NODE(entry_node,
+			_BT_COMP_LOGE_NODE(entry_node,
 				"Invalid clock class's `uuid` attribute.");
 			goto error;
 		}
 
 		clock->has_uuid = true;
-		memcpy(&clock->uuid[0], uuid, 16);
+		bt_uuid_copy(clock->uuid, uuid);
 		_SET(set, _CLOCK_UUID_SET);
-	} else if (!strcmp(left, "description")) {
+	} else if (strcmp(left, "description") == 0) {
 		char *right;
 
 		if (_IS_SET(set, _CLOCK_DESCRIPTION_SET)) {
-			_BT_LOGE_DUP_ATTR(entry_node, "description",
+			_BT_COMP_LOGE_DUP_ATTR(entry_node, "description",
 				"clock class");
 			ret = -EPERM;
 			goto error;
@@ -4426,7 +4343,7 @@ int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node,
 		right = concatenate_unary_strings(
 			&entry_node->u.ctf_expression.right);
 		if (!right) {
-			_BT_LOGE_NODE(entry_node,
+			_BT_COMP_LOGE_NODE(entry_node,
 				"Unexpected unary expression for clock class's `description` attribute.");
 			ret = -EINVAL;
 			goto error;
@@ -4435,26 +4352,26 @@ int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node,
 		g_string_assign(clock->description, right);
 		g_free(right);
 		_SET(set, _CLOCK_DESCRIPTION_SET);
-	} else if (!strcmp(left, "freq")) {
+	} else if (strcmp(left, "freq") == 0) {
 		uint64_t freq = UINT64_C(-1);
 
 		if (_IS_SET(set, _CLOCK_FREQ_SET)) {
-			_BT_LOGE_DUP_ATTR(entry_node, "freq", "clock class");
+			_BT_COMP_LOGE_DUP_ATTR(entry_node, "freq", "clock class");
 			ret = -EPERM;
 			goto error;
 		}
 
-		ret = get_unary_unsigned(
+		ret = get_unary_unsigned(ctx,
 			&entry_node->u.ctf_expression.right, &freq);
 		if (ret) {
-			_BT_LOGE_NODE(entry_node,
+			_BT_COMP_LOGE_NODE(entry_node,
 				"Unexpected unary expression for clock class's `freq` attribute.");
 			ret = -EINVAL;
 			goto error;
 		}
 
 		if (freq == UINT64_C(-1) || freq == 0) {
-			_BT_LOGE_NODE(entry_node,
+			_BT_COMP_LOGE_NODE(entry_node,
 				"Invalid clock class frequency: freq=%" PRIu64,
 				freq);
 			ret = -EINVAL;
@@ -4463,20 +4380,20 @@ int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node,
 
 		clock->frequency = freq;
 		_SET(set, _CLOCK_FREQ_SET);
-	} else if (!strcmp(left, "precision")) {
+	} else if (strcmp(left, "precision") == 0) {
 		uint64_t precision;
 
 		if (_IS_SET(set, _CLOCK_PRECISION_SET)) {
-			_BT_LOGE_DUP_ATTR(entry_node, "precision",
+			_BT_COMP_LOGE_DUP_ATTR(entry_node, "precision",
 				"clock class");
 			ret = -EPERM;
 			goto error;
 		}
 
-		ret = get_unary_unsigned(
+		ret = get_unary_unsigned(ctx,
 			&entry_node->u.ctf_expression.right, &precision);
 		if (ret) {
-			_BT_LOGE_NODE(entry_node,
+			_BT_COMP_LOGE_NODE(entry_node,
 				"Unexpected unary expression for clock class's `precision` attribute.");
 			ret = -EINVAL;
 			goto error;
@@ -4484,9 +4401,9 @@ int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node,
 
 		clock->precision = precision;
 		_SET(set, _CLOCK_PRECISION_SET);
-	} else if (!strcmp(left, "offset_s")) {
+	} else if (strcmp(left, "offset_s") == 0) {
 		if (_IS_SET(set, _CLOCK_OFFSET_S_SET)) {
-			_BT_LOGE_DUP_ATTR(entry_node, "offset_s",
+			_BT_COMP_LOGE_DUP_ATTR(entry_node, "offset_s",
 				"clock class");
 			ret = -EPERM;
 			goto error;
@@ -4495,35 +4412,35 @@ int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node,
 		ret = get_unary_signed(
 			&entry_node->u.ctf_expression.right, offset_seconds);
 		if (ret) {
-			_BT_LOGE_NODE(entry_node,
+			_BT_COMP_LOGE_NODE(entry_node,
 				"Unexpected unary expression for clock class's `offset_s` attribute.");
 			ret = -EINVAL;
 			goto error;
 		}
 
 		_SET(set, _CLOCK_OFFSET_S_SET);
-	} else if (!strcmp(left, "offset")) {
+	} else if (strcmp(left, "offset") == 0) {
 		if (_IS_SET(set, _CLOCK_OFFSET_SET)) {
-			_BT_LOGE_DUP_ATTR(entry_node, "offset", "clock class");
+			_BT_COMP_LOGE_DUP_ATTR(entry_node, "offset", "clock class");
 			ret = -EPERM;
 			goto error;
 		}
 
-		ret = get_unary_unsigned(
+		ret = get_unary_unsigned(ctx,
 			&entry_node->u.ctf_expression.right, offset_cycles);
 		if (ret) {
-			_BT_LOGE_NODE(entry_node,
+			_BT_COMP_LOGE_NODE(entry_node,
 				"Unexpected unary expression for clock class's `offset` attribute.");
 			ret = -EINVAL;
 			goto error;
 		}
 
 		_SET(set, _CLOCK_OFFSET_SET);
-	} else if (!strcmp(left, "absolute")) {
+	} else if (strcmp(left, "absolute") == 0) {
 		struct ctf_node *right;
 
 		if (_IS_SET(set, _CLOCK_ABSOLUTE_SET)) {
-			_BT_LOGE_DUP_ATTR(entry_node, "absolute",
+			_BT_COMP_LOGE_DUP_ATTR(entry_node, "absolute",
 				"clock class");
 			ret = -EPERM;
 			goto error;
@@ -4532,9 +4449,9 @@ int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node,
 		right = _BT_LIST_FIRST_ENTRY(
 			&entry_node->u.ctf_expression.right,
 			struct ctf_node, siblings);
-		ret = get_boolean(right);
+		ret = get_boolean(ctx, right);
 		if (ret < 0) {
-			_BT_LOGE_NODE(entry_node,
+			_BT_COMP_LOGE_NODE(entry_node,
 				"Unexpected unary expression for clock class's `absolute` attribute.");
 			ret = -EINVAL;
 			goto error;
@@ -4543,7 +4460,7 @@ int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node,
 		clock->is_absolute = ret;
 		_SET(set, _CLOCK_ABSOLUTE_SET);
 	} else {
-		_BT_LOGW_NODE(entry_node,
+		_BT_COMP_LOGW_NODE(entry_node,
 			"Unknown attribute in clock class: attr-name=\"%s\"",
 			left);
 	}
@@ -4665,7 +4582,7 @@ int visit_clock_decl(struct ctx *ctx, struct ctf_node *clock_node)
 	/* CTF 1.8's default frequency for a clock class is 1 GHz */
 	clock = ctf_clock_class_create();
 	if (!clock) {
-		_BT_LOGE_NODE(clock_node,
+		_BT_COMP_LOGE_NODE(clock_node,
 			"Cannot create default clock class.");
 		ret = -ENOMEM;
 		goto end;
@@ -4675,7 +4592,7 @@ int visit_clock_decl(struct ctx *ctx, struct ctf_node *clock_node)
 		ret = visit_clock_decl_entry(ctx, entry_node, clock, &set,
 			&offset_seconds, &offset_cycles);
 		if (ret) {
-			_BT_LOGE_NODE(entry_node,
+			_BT_COMP_LOGE_NODE(entry_node,
 				"Cannot visit clock class's entry: ret=%d",
 				ret);
 			goto end;
@@ -4683,7 +4600,7 @@ int visit_clock_decl(struct ctx *ctx, struct ctf_node *clock_node)
 	}
 
 	if (!_IS_SET(&set, _CLOCK_NAME_SET)) {
-		_BT_LOGE_NODE(clock_node,
+		_BT_COMP_LOGE_NODE(clock_node,
 			"Missing `name` attribute in clock class.");
 		ret = -EPERM;
 		goto end;
@@ -4739,7 +4656,7 @@ int visit_root_decl(struct ctx *ctx, struct ctf_node *root_decl_node)
 			root_decl_node->u.field_class_def.field_class_specifier_list,
 			&root_decl_node->u.field_class_def.field_class_declarators);
 		if (ret) {
-			_BT_LOGE_NODE(root_decl_node,
+			_BT_COMP_LOGE_NODE(root_decl_node,
 				"Cannot add field class found in root scope.");
 			goto end;
 		}
@@ -4748,7 +4665,7 @@ int visit_root_decl(struct ctx *ctx, struct ctf_node *root_decl_node)
 		ret = visit_field_class_alias(ctx, root_decl_node->u.field_class_alias.target,
 			root_decl_node->u.field_class_alias.alias);
 		if (ret) {
-			_BT_LOGE_NODE(root_decl_node,
+			_BT_COMP_LOGE_NODE(root_decl_node,
 				"Cannot add field class alias found in root scope.");
 			goto end;
 		}
@@ -4763,7 +4680,7 @@ int visit_root_decl(struct ctx *ctx, struct ctf_node *root_decl_node)
 		 */
 		ret = visit_field_class_specifier_list(ctx, root_decl_node, &decl);
 		if (ret) {
-			_BT_LOGE_NODE(root_decl_node,
+			_BT_COMP_LOGE_NODE(root_decl_node,
 				"Cannot visit root scope's field class: "
 				"ret=%d", ret);
 			BT_ASSERT(!decl);
@@ -4775,7 +4692,7 @@ int visit_root_decl(struct ctx *ctx, struct ctf_node *root_decl_node)
 		break;
 	}
 	default:
-		_BT_LOGE_NODE(root_decl_node,
+		_BT_COMP_LOGE_NODE(root_decl_node,
 			"Unexpected node type: node-type=%d",
 			root_decl_node->type);
 		ret = -EPERM;
@@ -4788,15 +4705,14 @@ end:
 
 BT_HIDDEN
 struct ctf_visitor_generate_ir *ctf_visitor_generate_ir_create(
-		bt_self_component_source *self_comp,
 		const struct ctf_metadata_decoder_config *decoder_config)
 {
 	struct ctx *ctx = NULL;
 
 	/* Create visitor's context */
-	ctx = ctx_create(self_comp, decoder_config);
+	ctx = ctx_create(decoder_config);
 	if (!ctx) {
-		BT_LOGE_STR("Cannot create visitor's context.");
+		BT_COMP_LOGE_STR("Cannot create visitor's context.");
 		goto error;
 	}
 
@@ -4849,7 +4765,7 @@ int ctf_visitor_generate_ir_visit_node(struct ctf_visitor_generate_ir *visitor,
 	int ret = 0;
 	struct ctx *ctx = (void *) visitor;
 
-	BT_LOGI_STR("Visiting metadata's AST to generate CTF IR objects.");
+	BT_COMP_LOGI_STR("Visiting metadata's AST to generate CTF IR objects.");
 
 	switch (node->type) {
 	case NODE_ROOT:
@@ -4867,7 +4783,7 @@ int ctf_visitor_generate_ir_visit_node(struct ctf_visitor_generate_ir *visitor,
 		if (ctx->ctf_tc->default_byte_order == -1) {
 			bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
 				if (got_trace_decl) {
-					_BT_LOGE_NODE(node,
+					_BT_COMP_LOGE_NODE(node,
 						"Duplicate trace (`trace` block).");
 					ret = -1;
 					goto end;
@@ -4875,7 +4791,7 @@ int ctf_visitor_generate_ir_visit_node(struct ctf_visitor_generate_ir *visitor,
 
 				ret = set_trace_byte_order(ctx, iter);
 				if (ret) {
-					_BT_LOGE_NODE(node,
+					_BT_COMP_LOGE_NODE(node,
 						"Cannot set trace's native byte order: "
 						"ret=%d", ret);
 					goto end;
@@ -4885,7 +4801,7 @@ int ctf_visitor_generate_ir_visit_node(struct ctf_visitor_generate_ir *visitor,
 			}
 
 			if (!got_trace_decl) {
-				BT_LOGD_STR("Incomplete AST: need trace (`trace` block).");
+				BT_COMP_LOGD_STR("Incomplete AST: need trace (`trace` block).");
 				ret = -EINCOMPLETE;
 				goto end;
 			}
@@ -4900,7 +4816,7 @@ int ctf_visitor_generate_ir_visit_node(struct ctf_visitor_generate_ir *visitor,
 		bt_list_for_each_entry(iter, &node->u.root.env, siblings) {
 			ret = visit_env(ctx, iter);
 			if (ret) {
-				_BT_LOGE_NODE(iter,
+				_BT_COMP_LOGE_NODE(iter,
 					"Cannot visit trace's environment (`env` block) entry: "
 					"ret=%d", ret);
 				goto end;
@@ -4916,7 +4832,7 @@ int ctf_visitor_generate_ir_visit_node(struct ctf_visitor_generate_ir *visitor,
 		bt_list_for_each_entry(iter, &node->u.root.clock, siblings) {
 			ret = visit_clock_decl(ctx, iter);
 			if (ret) {
-				_BT_LOGE_NODE(iter,
+				_BT_COMP_LOGE_NODE(iter,
 					"Cannot visit clock class: ret=%d",
 					ret);
 				goto end;
@@ -4934,7 +4850,7 @@ int ctf_visitor_generate_ir_visit_node(struct ctf_visitor_generate_ir *visitor,
 				siblings) {
 			ret = visit_root_decl(ctx, iter);
 			if (ret) {
-				_BT_LOGE_NODE(iter,
+				_BT_COMP_LOGE_NODE(iter,
 					"Cannot visit root entry: ret=%d",
 					ret);
 				goto end;
@@ -4946,7 +4862,7 @@ int ctf_visitor_generate_ir_visit_node(struct ctf_visitor_generate_ir *visitor,
 
 		/* Callsite blocks are not supported */
 		bt_list_for_each_entry(iter, &node->u.root.callsite, siblings) {
-			_BT_LOGW_NODE(iter,
+			_BT_COMP_LOGW_NODE(iter,
 				"\"callsite\" blocks are not supported as of this version.");
 		}
 
@@ -4957,7 +4873,7 @@ int ctf_visitor_generate_ir_visit_node(struct ctf_visitor_generate_ir *visitor,
 		bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
 			ret = visit_trace_decl(ctx, iter);
 			if (ret) {
-				_BT_LOGE_NODE(iter,
+				_BT_COMP_LOGE_NODE(iter,
 					"Cannot visit trace (`trace` block): "
 					"ret=%d", ret);
 				goto end;
@@ -4971,7 +4887,7 @@ int ctf_visitor_generate_ir_visit_node(struct ctf_visitor_generate_ir *visitor,
 		bt_list_for_each_entry(iter, &node->u.root.stream, siblings) {
 			ret = visit_stream_decl(ctx, iter);
 			if (ret) {
-				_BT_LOGE_NODE(iter,
+				_BT_COMP_LOGE_NODE(iter,
 					"Cannot visit stream class: ret=%d",
 					ret);
 				goto end;
@@ -4985,7 +4901,7 @@ int ctf_visitor_generate_ir_visit_node(struct ctf_visitor_generate_ir *visitor,
 		bt_list_for_each_entry(iter, &node->u.root.event, siblings) {
 			ret = visit_event_decl(ctx, iter);
 			if (ret) {
-				_BT_LOGE_NODE(iter,
+				_BT_COMP_LOGE_NODE(iter,
 					"Cannot visit event class: ret=%d",
 					ret);
 				goto end;
@@ -4997,7 +4913,7 @@ int ctf_visitor_generate_ir_visit_node(struct ctf_visitor_generate_ir *visitor,
 		break;
 	}
 	default:
-		_BT_LOGE_NODE(node,
+		_BT_COMP_LOGE_NODE(node,
 			"Unexpected node type: node-type=%d",
 			node->type);
 		ret = -EINVAL;
@@ -5005,7 +4921,8 @@ int ctf_visitor_generate_ir_visit_node(struct ctf_visitor_generate_ir *visitor,
 	}
 
 	/* Update default clock classes */
-	ret = ctf_trace_class_update_default_clock_classes(ctx->ctf_tc);
+	ret = ctf_trace_class_update_default_clock_classes(ctx->ctf_tc,
+		&ctx->log_cfg);
 	if (ret) {
 		ret = -EINVAL;
 		goto end;
@@ -5033,7 +4950,7 @@ int ctf_visitor_generate_ir_visit_node(struct ctf_visitor_generate_ir *visitor,
 	}
 
 	/* Resolve sequence lengths and variant tags */
-	ret = ctf_trace_class_resolve_field_classes(ctx->ctf_tc);
+	ret = ctf_trace_class_resolve_field_classes(ctx->ctf_tc, &ctx->log_cfg);
 	if (ret) {
 		ret = -EINVAL;
 		goto end;
@@ -5062,7 +4979,7 @@ int ctf_visitor_generate_ir_visit_node(struct ctf_visitor_generate_ir *visitor,
 	}
 
 	/* Validate what we have so far */
-	ret = ctf_trace_class_validate(ctx->ctf_tc);
+	ret = ctf_trace_class_validate(ctx->ctf_tc, &ctx->log_cfg);
 	if (ret) {
 		ret = -EINVAL;
 		goto end;
@@ -5073,11 +4990,12 @@ int ctf_visitor_generate_ir_visit_node(struct ctf_visitor_generate_ir *visitor,
 	 * itself in the packet header and in event header field
 	 * classes, warn about it because they are never translated.
 	 */
-	ctf_trace_class_warn_meaningless_header_fields(ctx->ctf_tc);
+	ctf_trace_class_warn_meaningless_header_fields(ctx->ctf_tc,
+		&ctx->log_cfg);
 
 	if (ctx->trace_class) {
 		/* Copy new CTF metadata -> new IR metadata */
-		ret = ctf_trace_class_translate(ctx->self_comp,
+		ret = ctf_trace_class_translate(ctx->log_cfg.self_comp,
 				ctx->trace_class, ctx->ctf_tc);
 		if (ret) {
 			ret = -EINVAL;