C/C++ macro to repeat code

Question

is there any way to repeat a C code N times with a macro? Also N is a macro.
For example if I have this macros:

#define N 5  
#define COODE "nop\n\t"
#define REPEAT [...]

When I call repeat the preprocessor writes CODE N times, so

 __asm__(REPEAT);

would became

__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t""nop\n\t");

I have an Arduino that have to wait for an exact (and small, about 10-15) number of clock. Each "nop" (no operation) takes exactly 1 clock cycle to be executed, and it does nothing. I can't just do a cycle, because each cycle is executed in more than one operation (initialize the counter, increment the counter, check if reached end), so instead of writing manually "nop\n\t" I'd like to have a macro. This way I can also simply change N to modify the program without rewriting it.

Thank you in advance

Figure out the time it takes to set up a loop, and the time to do one iteration... if the time needed is larger that the sum, do the setup plus as many iterations as needed to almost reach your total, then just a few `nop`s to finish out the delay. It's more effort to write but much more compact. — Dmitri, Nov 17 '14 at 23:05
..If the delay isn't that long, try a macro for say 5 `nop`s to save typing, but I don't think theres a way to make a "paste this N times" macro as you've requested. — Dmitri, Nov 17 '14 at 23:08
You can make n macros though, where n is the max number of repeats you may need. Something like `#define _5(x) x ## _4(x)` where _1(x) ... _4(x) would look similar — technosaurus, Nov 17 '14 at 23:12
If you're willing to `#include` a file recursively, you can cook something up... — Kerrek SB, Nov 17 '14 at 23:14
Why are you repeating code rather than using a `for` loop or calling a `delay` function? — Thomas Matthews, Nov 17 '14 at 23:14
Many assembly languages have macros for repeating blocks of code. You may want to write a delay in assembly code. — Thomas Matthews, Nov 17 '14 at 23:16
can't you use something like this: #define print(X) for(int i = 0 ;i<=X;++i) printf("hello") — mchouhan_google, Nov 18 '14 at 08:14
Have a look at http://stackoverflow.com/questions/319328/writing-a-while-loop-in-the-c-pre-processor for generating loops using macros — cup, Nov 19 '14 at 13:02

Chris A · Accepted Answer · 2015-07-26T10:29:09.503

If you want to do it without including a whole library or using define, you can use a simple recursive template:

//By Christopher Andrews, released under MIT licence.

template< unsigned N > struct Nops{
  static void generate() __attribute__((always_inline)){
    __asm__ volatile ("nop");
    Nops< N - 1 >::generate();
  }
};
template<> struct Nops<0>{ static inline void generate(){} };

void setup() {
  Nops<10>::generate();
}

void loop(){}

This will generate the exact number of nop's required.

0000010a setup:
10a: 00 00 nop
10c: 00 00 nop
10e: 00 00 nop
110: 00 00 nop
112: 00 00 nop
114: 00 00 nop
116: 00 00 nop
118: 00 00 nop
11a: 00 00 nop
11c: 00 00 nop
11e: 08 95 ret

I have used this method in a TFT driver for Arduino.

EDIT:

There is another way to easily do this on an AVR compiled with avr-gcc. I'm assuming this may not be available on older toolchains.

In order to delay execution for a specific number of cycles, GCC implements

void __builtin_avr_delay_cycles (unsigned long ticks) ticks is the number of ticks to delay execution. Note that this built-in does not take into account the effect of interrupts which might increase delay time. ticks must be a compile time integer constant; delays with a variable number of cycles are not supported

From here: https://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/AVR-Built_002din-Functions.html

+1 for the C++ non-preprocessor solution. Exactly one of those edge cases where unrolling the loop at compile-time using template programming is extremely useful. — CompuChip, Mar 19 '15 at 12:46

score 4 · Answer 2 · answered Aug 11 '17 at 08:18

The following code works with GNU C,

#define NOP __asm__("nop")

#define ten(a)     a;a;a;a;a;a;a;a;a;a
#define handred(a) ten(ten(a))


int
main()
{
    handred(NOP);
    return 0;
}

Compile and debug:

code@lab:~/debug$ gcc -g -o debug_NOP debug_NOP.c
code@lab:~/debug$ gdb -q --nh debug_NOP
Reading symbols from debug_NOP...done.
(gdb) set disassembly-flavor intel
(gdb) start
Temporary breakpoint 1 at 0x664: file debug_NOP.c, line 10.
Starting program: /home/code/debug/debug_NOP 

Temporary breakpoint 1, main () at debug_NOP.c:10
10      handred(NOP);
(gdb) disassemble 
Dump of assembler code for function main:
   0x0000555555554660 <+0>: push   rbp
   0x0000555555554661 <+1>: mov    rbp,rsp
=> 0x0000555555554664 <+4>: nop
   0x0000555555554665 <+5>: nop
   0x0000555555554666 <+6>: nop
   0x0000555555554667 <+7>: nop
   0x0000555555554668 <+8>: nop
   0x0000555555554669 <+9>: nop
   ....
   0x00005555555546c6 <+102>:   nop
   0x00005555555546c7 <+103>:   nop
   0x00005555555546c8 <+104>:   mov    eax,0x0
   0x00005555555546cd <+109>:   pop    rbp
   0x00005555555546ce <+110>:   ret    
End of assembler dump.

score 2 · Answer 3 · answered Nov 20 '14 at 17:21

Boost has Boost.Preprocessor which does this among other things. From:

http://www.boost.org/doc/libs/1_57_0/libs/preprocessor/doc/index.html

BOOST_PP_REPEAT

For your code:

#include <boost/preprocessor/repetition/repeat.hpp>

#define OP(z, n, text) text
...
__asm__( BOOST_PP_REPEAT(5, OP, "noop\n"\t);

score 1 · Answer 4 · answered Aug 18 '20 at 12:47

Based on Chris A's answer, here's a bit simpler approach which also seems to work for me:

template< unsigned N > 
inline static void nops(){
    asm ("nop");
    nops< N - 1 >();
}

template<> inline void nops<0>(){};

void setup() {
  nops<10>();
}

https://godbolt.org/z/a7MMea

C/C++ macro to repeat code

4 Answers4

EDIT: