Skip to content

failure to preprocess zephyr (blinky example) #549

@danmar

Description

@danmar

Reduced example code:

#define DT_DRV_COMPAT renesas_ra_external_interrupt
#define DT_FOREACH_OKAY_INST_renesas_ra_external_interrupt(fn) fn(0) fn(1)
#define _DO_CONCAT(x, y) x ## y
#define _CONCAT(x, y) _DO_CONCAT(x, y)
#define Z_IS_ENABLED1(config_macro) Z_IS_ENABLED2(_XXXX##config_macro)
#define _XXXX1 _YYYY,
#define Z_IS_ENABLED2(one_or_two_args) Z_IS_ENABLED3(one_or_two_args 1, 0)
#define Z_IS_ENABLED3(ignore_this, val, ...) val
#define Z_COND_CODE_1(_flag, _if_1_code, _else_code)	__COND_CODE(_XXXX##_flag, _if_1_code, _else_code)
#define Z_COND_CODE_0(_flag, _if_0_code, _else_code)	__COND_CODE(_ZZZZ##_flag, _if_0_code, _else_code)
#define _ZZZZ0 _YYYY,
#define __COND_CODE(one_or_two_args, _if_code, _else_code)	__GET_ARG2_DEBRACKET(one_or_two_args _if_code, _else_code)
#define __GET_ARG2_DEBRACKET(ignore_this, val, ...) __DEBRACKET val
#define __DEBRACKET(...) __VA_ARGS__
#define UTIL_CAT(a, ...) UTIL_PRIMITIVE_CAT(a, __VA_ARGS__)
#define UTIL_PRIMITIVE_CAT(a, ...) a##__VA_ARGS__
#define IS_BIT_SET(value, bit) ((((value) >> (bit)) & (0x1)) != 0)
#define COND_CODE_1(_flag, _if_1_code, _else_code)	Z_COND_CODE_1(_flag, _if_1_code, _else_code)
#define IS_EQ(a, b) Z_IS_EQ(a, b)
#define DT_NODE_VENDOR_BY_IDX_OR(node_id, idx, default_value)	COND_CODE_1(DT_NODE_VENDOR_HAS_IDX(node_id, idx), (DT_NODE_VENDOR_BY_IDX(node_id, idx)), (default_value))

#define DT_INST_FOREACH_STATUS_OKAY(fn) \
	COND_CODE_1(DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT),	\
		    (UTIL_CAT(DT_FOREACH_OKAY_INST_,		\
			      DT_DRV_COMPAT)(fn)),		\
		    ())

#define Z_INIT_PRE_KERNEL_1_PRE_KERNEL_1 1
#define INIT_LEVEL_ORD(level)                                                  \
	COND_CODE_1(Z_INIT_EARLY_##level, (Z_INIT_ORD_EARLY),                  \
	(COND_CODE_1(Z_INIT_PRE_KERNEL_1_##level, (Z_INIT_ORD_PRE_KERNEL_1),   \
	(COND_CODE_1(Z_INIT_PRE_KERNEL_2_##level, (Z_INIT_ORD_PRE_KERNEL_2),   \
	(COND_CODE_1(Z_INIT_POST_KERNEL_##level, (Z_INIT_ORD_POST_KERNEL),     \
	(COND_CODE_1(Z_INIT_APPLICATION_##level, (Z_INIT_ORD_APPLICATION),     \
	(COND_CODE_1(Z_INIT_SMP_##level, (Z_INIT_ORD_SMP),                     \
	(ZERO_OR_COMPILE_ERROR(0)))))))))))))


#define TYPE_SECTION_ITERABLE(type, varname, secname, section_postfix) \
	Z_DECL_ALIGN(type) varname \
	__in_section(_##secname, static, _CONCAT(section_postfix, _)) __used __noasan

#define STRUCT_SECTION_ITERABLE_NAMED_ALTERNATE(struct_type, secname, name, varname) \
	TYPE_SECTION_ITERABLE(struct struct_type, varname, secname, name)

#define DEVICE_DT_DEINIT_DEFINE(node_id, init_fn, deinit_fn, pm, data, config, \
				level, prio, api, ...)                         \
	Z_DEVICE_STATE_DEFINE(Z_DEVICE_DT_DEV_ID(node_id));                    \
	Z_DEVICE_DEFINE(node_id, Z_DEVICE_DT_DEV_ID(node_id),                  \
			DEVICE_DT_NAME(node_id), init_fn, deinit_fn,           \
			Z_DEVICE_DT_FLAGS(node_id), pm, data, config, level,   \
			prio, api,                                             \
			&Z_DEVICE_STATE_NAME(Z_DEVICE_DT_DEV_ID(node_id)),     \
			__VA_ARGS__)

#define DEVICE_DT_DEFINE(node_id, init_fn, pm, data, config, level, prio, api, \
			 ...)                                                  \
	DEVICE_DT_DEINIT_DEFINE(node_id, init_fn, NULL, pm, data, config,      \
				level, prio, api, __VA_ARGS__)

#define DEVICE_DT_INST_DEFINE(inst, ...)	DEVICE_DT_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)

#define Z_DEVICE_SECTION_NAME(level, prio)	_CONCAT(INIT_LEVEL_ORD(level), _##prio)

#define Z_DEVICE_BASE_DEFINE(node_id, dev_id, name, init_fn, deinit_fn, flags, pm, data, config,   \
			     level, prio, api, state, deps)                                        \
	COND_CODE_1(DT_NODE_EXISTS(node_id), (), (static))                                         \
	COND_CODE_1(Z_DEVICE_IS_MUTABLE(node_id), (), (const))                                     \
	STRUCT_SECTION_ITERABLE_NAMED_ALTERNATE(                                                   \
		device, COND_CODE_1(Z_DEVICE_IS_MUTABLE(node_id), (device_mutable), (device)),     \
		Z_DEVICE_SECTION_NAME(level, prio), DEVICE_NAME_GET(dev_id)) =                     \
		Z_DEVICE_INIT(name, init_fn, deinit_fn, flags, pm, data, config, api, state, deps, \
			      node_id, dev_id)

#define Z_DEVICE_CHECK_INIT_LEVEL(level)                                       \
	COND_CODE_1(Z_INIT_PRE_KERNEL_1_##level, (),                           \
	(COND_CODE_1(Z_INIT_PRE_KERNEL_2_##level, (),                          \
	(COND_CODE_1(Z_INIT_POST_KERNEL_##level, (),                           \
	(ZERO_OR_COMPILE_ERROR(0)))))))

#define Z_DEVICE_INIT_ENTRY_DEFINE(node_id, dev_id, level, prio)                                   \
	Z_DEVICE_CHECK_INIT_LEVEL(level)                                                           \
                                                                                                   \
	static const Z_DECL_ALIGN(struct init_entry) __used __noasan Z_INIT_ENTRY_SECTION(         \
		level, prio, Z_DEVICE_INIT_SUB_PRIO(node_id))                                      \
		Z_INIT_ENTRY_NAME(DEVICE_NAME_GET(dev_id)) = {                                     \
			.init_fn = NULL,                                                           \
			.dev = (const struct device *)&DEVICE_NAME_GET(dev_id),                    \
		}

#define Z_DEVICE_DEFINE(node_id, dev_id, name, init_fn, deinit_fn, flags, pm,   \
			data, config, level, prio, api, state, ...)             \
	Z_DEVICE_NAME_CHECK(name);                                              \
                                                                                \
	IF_ENABLED(CONFIG_DEVICE_DEPS,                                          \
		   (Z_DEVICE_DEPS_DEFINE(node_id, dev_id, __VA_ARGS__);))       \
                                                                                \
	IF_ENABLED(CONFIG_DEVICE_DT_METADATA,                                   \
		   (IF_ENABLED(DT_NODE_EXISTS(node_id),                         \
			      (Z_DEVICE_DT_METADATA_DEFINE(node_id, dev_id);))))\
                                                                                \
	Z_DEVICE_BASE_DEFINE(node_id, dev_id, name, init_fn, deinit_fn, flags,  \
			     pm, data, config, level, prio, api, state,         \
			     Z_DEVICE_DEPS_NAME(dev_id));                       \
                                                                                \
	Z_DEVICE_INIT_ENTRY_DEFINE(node_id, dev_id, level, prio);               \
                                                                                \
	IF_ENABLED(CONFIG_LLEXT_EXPORT_DEVICES,                                 \
		(IF_ENABLED(DT_NODE_EXISTS(node_id),                            \
				(Z_DEVICE_EXPORT(node_id);))))

#define EVENT_ICU_IRQ(channel) BSP_PRV_IELS_ENUM(CONCAT(EVENT_ICU_IRQ, channel))

#define GPIO_INTERRUPT_INIT(index)                                                                 \
	static const struct gpio_ra_irq_config gpio_ra_irq_config##index = {                       \
		.reg = DT_INST_REG_ADDR(index),                                                    \
		.channel = DT_INST_PROP(index, channel),                                           \
		.trigger =                                                                         \
			DT_INST_ENUM_IDX_OR(index, renesas_trigger, EXT_INTERRUPT_EDGE_FALLING),   \
		.digital_filter = DT_INST_PROP_OR(index, renesas_digital_filtering, false),        \
		.sample_clock = UTIL_CAT(EXT_INTERRUPT_SAMPLE_CLOCK_DIV_,                          \
					 DT_INST_PROP_OR(index, renesas_sample_clock_div, 1)),     \
		.irq = DT_INST_IRQ(index, irq),                                                    \
	};                                                                                         \
	static struct gpio_ra_irq_data gpio_ra_irq_data##index;                                    \
	static int gpio_ra_irq_init##index(const struct device *dev)                               \
	{                                                                                          \
		R_ICU->IELSR[DT_INST_IRQ(index, irq)] =                                            \
			EVENT_ICU_IRQ(DT_INST_PROP(index, channel));                               \
                                                                                                   \
		BSP_ASSIGN_EVENT_TO_CURRENT_CORE(EVENT_ICU_IRQ(DT_INST_PROP(index, channel)));     \
                                                                                                   \
		IRQ_CONNECT(DT_INST_IRQ(index, irq), DT_INST_IRQ(index, priority), gpio_ra_isr,    \
			    DEVICE_DT_INST_GET(index), 0);                                         \
		return gpio_ra_interrupt_init(dev);                                                \
	};                                                                                         \
	DEVICE_DT_INST_DEFINE(index, gpio_ra_irq_init##index, NULL, &gpio_ra_irq_data##index,      \
			      &gpio_ra_irq_config##index, PRE_KERNEL_1, CONFIG_GPIO_INIT_PRIORITY, \
			      NULL);

DT_INST_FOREACH_STATUS_OKAY(GPIO_INTERRUPT_INIT)

gcc can preprocess this code without errors but simplecpp generates this error:

syntax error: failed to expand 'DT_INST_FOREACH_STATUS_OKAY', Wrong number of parameters for macro 'TYPE_SECTION_ITERABLE'.

Metadata

Metadata

Assignees

No one assigned

    Labels

    Projects

    No projects

    Milestone

    No milestone

    Relationships

    None yet

    Development

    No branches or pull requests

    Issue actions