Can `memset` function call be removed by compiler?

Question

I have read here that compiler is free to remove call to `memset` if it knows that passed memory buffer is never used again. How is that possible? It seems to me that (from the point of view of core language) `memset` is just a regular function, and compiler has no right to assume that whatever happens inside it, will have no side effects. In linked article they show how Visual C++ 10 removed `memset`. I know that Microsoft compilers are not leading in standard compliance, so I ask - is it according to standard, or is it just msvc-ism? If it's according to standard, please elaborate ;) EDIT: @Cubbi Following code: ``` void testIt(){ char foo[1234]; for (int i=0; i<1233; i++){ foo[i] = rand()%('Z'-'A'+1)+'A'; } foo[1233]=0; printf(foo); memset(foo, 0, 1234); } ``` Compiled under mingw with lines: ``` g++ -c -O2 -frtti -fexceptions -mthreads -Wall -DUNICODE -o main.o main.cpp g++ -Wl,-s -Wl,-subsystem,console -mthreads -o main.exe main.o objdump -d -M intel -S main.exe > dump.asm ``` Ga…

Accepted Answer

"compiler has no right to assume that whatever happens inside it, will have no side effects."

That's correct. But if the compiler in fact knows what actually happens inside it and can determine that it really has no side effects, then no assumption is needed.

This is how almost all compiler optimizations work. The code says "X". The compiler determines that if "Y" is true, then it can replace code "X" with code "Z" and there will be no detectable difference. It determines "Y" is true, and then it replaces "X" with "Z".

For example:

```
void func()
{
  int j = 2;
  foo();
  if (j == 2) bar();
   else baz();
}
```

The compiler can optimize this to `foo(); bar();`. The compiler can see that `foo` cannot legally modify the value of `j`. If `foo()` somehow magically figures out where `j` is on the stack and modifies it, then the optimization will change the behavior of the code, but that's the programmer's fault for using "magic".

```
void func()
{
  int j = 2;
  foo(&j);
  if (j == 2) bar();
   else baz();
}
```

Now it can't because `foo` can legally modify the value of `j` without any magic. (Assuming the compiler can't look inside `foo`, which in some cases it can.)

If you do "magic", then the compiler can make optimizations that break your code. Stick to the rules and don't use magic.

In the example you linked to, the code relies on the compiler bothering to put a particular value in a variable that is never accessed and immediately ceases to exist. The compiler is not required to do anything that has no effect on the operation of your code.

The only way that could effect the code is if it peeked at unallocated portions of the stack or relied on new allocations on the stack having values they previously had. Requiring the compiler to do that would make a huge number of optimizations impossible, including replacing local variables with registers.

Can `memset` function call be removed by compiler?

Solution

Problem