[RFC] Preprocessor-Based Arithmetic and Condition Evaluation in Zephyr

[soburi]

It's still in the early stages of implementation and not in perfect condition, but I think it might interest everyone, so I'll put it out as a draft first.

Problem

Currently, DeviceTree macros face limitations in setting flexible compile-time conditions. Specifically, COND_CODE_1 evaluates whether a given argument is 1 or not, but deriving this 1 using only macros can be challenging in certain cases.

Proposed Solution (Overview)

Introduce the capability to perform "calculations" using the preprocessor, allowing for flexible condition evaluation. The following example demonstrates the proposed functionality:

/* (1 + 2 == 9) is not true, so the 3rd argument will remains. */
COND_CODE_1(
    EXPR_IS_TRUE(EXPR_EQ(EXPR_ADD(EXPR_HEX(0x1), EXPR_HEX(0x2)), EXPR_HEX(0x9))),
    (zassert_unreachable("unreachable")),
    (zassert_true(1))
);

Proposed Solution (Details)

To address the problem, implement 32-bit arithmetic calculations with macros. Numbers will be represented as lists of 0 and 1 arguments (referred to as "bit args"). Using these bit args, the following operations will be provided:

• Comparison operations:
  • EQ(= ,equal)
  • GT(>, greater than)
  • LT(<, less than)
  • GTE(>=, greater than equal)
  • LTE(<=, less than equal)
• Bitwise operations:
  • OR(|)
  • AND(&)
  • XOR(^)
  • NOT(~)
• Arithmetic operations:
  • ADD(+, addition)
  • SUB(-, subtraction)
  • MUL(*, multiplication)
  • DIV(/, division)
  • MOD(%, modulus)

This enables complex conditional expressions to be evaluated entirely within the preprocessor.
In other words, it is a proposal to implement a simple computer using only macros.

Considerations

1. Performance

   Multiplication and division are inherently slower operations. They may need to be avoided in CI environments for performance reasons.
   Introducing a mechanism to limit the bit width of calculations could improve usability and efficiency.

2. Limitations of Number Representations

   Due to the constraints of the preprocessor, decimal and hexadecimal literals cannot be directly handled. These must first be converted into the internal bit args representation.
   To facilitate this, lookup tables containing up to 4096 entries for both decimal and hexadecimal numbers have been defined. However, this approach has limitations.

Internally, it is possible to generate hexadecimal literals from bit args with ease. As such, outputting results in hexadecimal is unrestricted.

The limitations can be summarized as follows:

Format	Input Support	Output Support
bit args	✓	✓
Hexadecimal	Table-dependent	✓
Decimal	Table-dependent	Table-dependent

3. Integration with DeviceTree

   This functionality is designed to work alongside DeviceTree macros.
   Most use cases can be supported by modifying devicetree_generated.h to include bit args values.
   Exceptions may arise when dealing with literals defined in existing headers, which would require manual handling.

Benefits

This feature enables flexible conditional branching and complex calculations at compile time, enhancing the power and versatility of DeviceTree macros.