6

I am instrumenting some code and noticed that with the C++14 features there are two new delete operators (From http://en.cppreference.com/w/cpp/memory/new/operator_delete):

These are 5-6) Called instead of (1-2) if a user-defined replacement is provided except that it's implementation-defined whether (1-2) or (5-6) is called when deleting objects of incomplete type and arrays of non-class and trivially-destructible class types (since C++17). The standard library implementations are identical to (1-2).

I have overloaded these and wanted to call these two exclusively. When I overload these two with gcc I don't have a problem. With clang++ I get an undefined reference to operator delete(void*)

Here is the code

void* operator new(long unsigned int howMuch) {
    return reinterpret_cast<void*>(0xdeadbeef);
}

void* operator new[](long unsigned int howMuch) {
    return reinterpret_cast<void*>(0xdeadbeef);
}

void operator delete(void* what, long unsigned int howmuch) {
        if(what != reinterpret_cast<void*>(0xdeadbeef)) __builtin_trap();
        if(howmuch != 1) __builtin_trap();
}

extern "C"
void _start() {
    delete new char;
    asm("syscall" : : "a"(60) : ); 
}

Compiled with gcc: g++ -ggdb -std=c++14 -nostdlib -fno-builtin -fno-exceptions 1.cc there is no problem and it runs fine.

Is it possible to do this with llvm/clang?

Toby Speight
  • 27,591
  • 48
  • 66
  • 103
Peter Stpme
  • 71
  • 4
  • 9
    Clang needs `-fsized-deallocation` in order to call the two-parameter `operator delete`. – T.C. Jan 29 '16 at 08:23
  • @T.C.: Could it be that clang is taking quite some liberties with the language standard? In a [different Q&A](http://stackoverflow.com/a/5590404/60281) some confusion popped up about clang not enabling RTTI by default and thus rejecting perfectly fine code as well... I don't think they are doing people a favour with only accepting a subset of C++ by default. – DevSolar Jan 29 '16 at 08:30
  • 4
    @DevSolar I've never heard of clang disabling RTTI by default. Perhaps that guy meant that building LLVM uses `-fno-rtti`? As for sized deallocation, there are various ABI issues - see http://reviews.llvm.org/D8467. – T.C. Jan 29 '16 at 08:38
  • @T.C. thanks. That was the switch. ABI problems don't affect us as this is just some instrumentation and everything is recompiled and statically linked. – Peter Stpme Jan 29 '16 at 08:55
  • 3
    @DevSolar Clang disables `-fsized-deallocation` by default in C++14 mode in the current releases because it is not supported by widely-deployed C++ ABI libraries. If it were not disabled by default, C++14 code would not link in most current deployments. We intend to change the default once C++14 ABI libraries become more common. – Richard Smith Feb 04 '16 at 21:36
  • @RichardSmith Tough call - but that's not an obviously stupid engineering decision. – Martin Bonner supports Monica Jan 13 '19 at 15:57

1 Answers1

1

You can explicitly call sized or non-sized delete operators like this: 

char* ptr = new char;
delete ptr; // compiler selects which to call
operator delete(ptr); // explicitly call the non-sized delete 
operator delete(ptr, 1); // explicitly call sized delete

For a full example:

void* operator new(long unsigned int howMuch) {                                                                                                                                               
    return reinterpret_cast<void*>(0xdeadbeef);
}

void* operator new[](long unsigned int howMuch) {
    return reinterpret_cast<void*>(0xdeadbeef);
}

void operator delete(void* what) {
    if(what != reinterpret_cast<void*>(0xdeadbeef)) __builtin_trap();
}

void operator delete(void* what, long unsigned int howmuch) {
    if(what != reinterpret_cast<void*>(0xdeadbeef)) __builtin_trap();
    if(howmuch != 1) __builtin_trap();
}

extern "C"
void _start() {
    char* ptr = new char;
    delete ptr;
    operator delete(ptr);
    operator delete(ptr, 1);
    asm("syscall" : : "a"(60) : ); 
}

Compiling and looking at generated code it is clear which operators are called when:

$ clang++ -std=c++14 -nostdlib  -fno-builtin  -fno-exceptions -fsized-deallocation sized-deallocation.cpp -o sized-deallocation.bin && gdb -batch -ex 'file sized-deallocation.bin' -ex 'disassemble _start' | c++filt
Dump of assembler code for function _start:
   0x0000000000401070 <+0>: push   %rbp
   0x0000000000401071 <+1>: mov    %rsp,%rbp
   0x0000000000401074 <+4>: sub    $0x10,%rsp
   0x0000000000401078 <+8>: mov    $0x1,%eax
   0x000000000040107d <+13>:    mov    %eax,%edi
   0x000000000040107f <+15>:    callq  0x401000 <operator new(unsigned long)>
   0x0000000000401084 <+20>:    mov    %rax,-0x8(%rbp)
   0x0000000000401088 <+24>:    mov    -0x8(%rbp),%rax
   0x000000000040108c <+28>:    cmp    $0x0,%rax
   0x0000000000401090 <+32>:    mov    %rax,-0x10(%rbp)
   0x0000000000401094 <+36>:    je     0x4010aa <_start+58>
   0x000000000040109a <+42>:    mov    $0x1,%eax
   0x000000000040109f <+47>:    mov    %eax,%esi
   0x00000000004010a1 <+49>:    mov    -0x10(%rbp),%rdi
   0x00000000004010a5 <+53>:    callq  0x401040 <operator delete(void*, unsigned long)>
   0x00000000004010aa <+58>:    mov    -0x8(%rbp),%rdi
   0x00000000004010ae <+62>:    callq  0x401020 <operator delete(void*)>
   0x00000000004010b3 <+67>:    mov    $0x1,%eax
   0x00000000004010b8 <+72>:    mov    %eax,%esi
   0x00000000004010ba <+74>:    mov    -0x8(%rbp),%rdi
   0x00000000004010be <+78>:    callq  0x401040 <operator delete(void*, unsigned long)>
   0x00000000004010c3 <+83>:    mov    $0x3c,%eax
   0x00000000004010c8 <+88>:    syscall 
   0x00000000004010ca <+90>:    add    $0x10,%rsp
   0x00000000004010ce <+94>:    pop    %rbp
   0x00000000004010cf <+95>:    retq   
End of assembler dump.

The actual reason though why you are getting undefined reference to `operator delete(void*)' with Clang is that (as @T.C. said) Clang needs the -fsized-deallocation flag to enable C++14 sized deallocation.

Your example compiles without error if the following command is used:

clang++ -ggdb -std=c++14 -nostdlib  -fno-builtin  -fno-exceptions -fsized-deallocation 1.cc

Since Clang 3.7 C++14 sized deallocation is disabled by default:

C++ Support in Clang > C++14 implementation status > C++ Sized Deallocation N3778

(7): In Clang 3.7 and later, sized deallocation is only enabled if the user passes the -fsized-deallocation flag. The user must supply definitions of the sized deallocation functions, either by providing them explicitly or by using a C++ standard library that does. libstdc++ added these functions in version 5.0, and libc++ added them in version 3.7.

Clang 3.7 Release Notes > What’s New in Clang 3.7? > New Compiler Flags

The sized deallocation feature of C++14 is now controlled by the -fsized-deallocation flag. This feature relies on library support that isn’t yet widely deployed, so the user must supply an extra flag to get the extra functionality.

The reasoning for this change was that these functions were missing in widely deployed standard libraries at the time (2015-03-19):

C++14: Disable sized deallocation by default due to ABI breakage

There are no widely deployed standard libraries providing sized deallocation functions, so we have to punt and ask the user if they want us to use sized deallocation. In the future, when such libraries are deployed, we can teach the driver to detect them and enable this feature.

The manual entry for this option can be found here:

Clang command line argument reference > Compilation flags > Target-independent compilation options

-fsized-deallocation, -fno-sized-deallocation

Enable C++14 sized global deallocation functions

Iwan Aucamp
  • 1,469
  • 20
  • 21