Implementations for asm("nop") in windows

Is an empty line of code that ends with a semicolon equivelent to an asm("nop") instruction?

volatile int x = 5;

if(x == 5){
  printf("x has not been changed yet\n");
}
else{
  ;//Is this the same as asm("nop") or __asm nop in windows?
  //alternatively could use __asm nop or __nop();
}

I looked at this answer and it makes me not want to use an x86 specific implementation of using inline assembly. Is `__asm nop` the Windows equivalent of `asm volatile("nop");` from GCC compiler

I can use this void __nop(); function that msdn seems to recommend, but I don't want to drag in the library if I don't have to. https://learn.microsoft.com/en-us/cpp/intrinsics/nop?view=vs-2017

Is there a cheap, portable way to add a nop instruction that won't get compiled out? I thought an empty semicolon either was nop or compiled out but I can't find any info on it tonight for some reason.

CLARIFICATION EDIT I can use inline asm to do this for x86 but I would like it to be portable. I can use the windows library __nop() but I don't want to import the library into my project, its undesirable overhead.

I am looking for a cleaver way to generate a NOP instruction that will not be optimized out (with standard C syntax preferably) that can be made into a MACRO and used throughout a project, having minimal overhead and works (or can easy be improved to work) on windows/linux/x86/x64.

Thanks.

Solution

I mean i don't want to add a library just to force the compiler to add a NOP.

... in a way that is independent of compiler settings (such as optimization settings) and in a way that works with all Visual C++ versions (and maybe even other compilers):

No chance: A compiler is free on how it is generating code as long as the assembler code has the behavior the C code is describing.

And because the NOP instruction does not change the behavior of the program, the compiler is free to add it or to leave it out.

Even if you found a way to force the compiler to generate a NOP: One update of the compiler or a Windows update modifying some file and the compiler might not generate the NOP instruction any longer.

I can use inline asm to do this for x86 but I would like it to be portable.

As I wrote above, any way to force the compiler to write a NOP would only work on a certain compiler version for a certain CPU.

Using inline assembly or __nop() you might cover all compilers of a certain manufacturer (for example: all GNU C compilers or all variants of Visual C++ etc...).

Another question would be: Do you explicitly need the "official" NOP instruction or can you live with any instruction that does nothing?

If you could live with any instruction doing (nearly) nothing, reading a global or static volatile variable could be a replacement for NOP:

static volatile char dummy;
    ...
else
{
    (void)dummy;
}

This should force the compiler to add a MOV instruction reading the variable dummy.

Background:

If you wrote a device driver, you could link the variable dummy to some location where reading the variable has "side-effects". Example: Reading a variable located in VGA video memory can cause influence the screen content!

Using the volatile keyword you do not only tell the compiler that the value of the variable may change at any time, but also that reading the variable may have such effects.

This means that the compiler has to assume that not reading the variable causes the program not to work correctly. It cannot optimize away the (actually unnecessary) MOV instruction reading the variable.