0

I doubt if gcc 4.8.3 inlines incorrect template functions... This problem does not occur in debug mode, but only in optimized mode. However this happens in a complicated code base, I am not able to reproduce the issue in a simple test case.

My code is like the following

#include "stdio.h"

class A {
 public:

    template<typename T> int WriteNative(const T) { 
      printf("here?\n")
      return 0; 
    }

    template<typename D> 
        void doit() {
        if (WriteNative<double>(1)) {
            printf("A\n");
        } else {
            printf("B\n");
        }
    }

};

// in my real code, this definition is in a different cpp file
template<> int A::WriteNative<double>(const double) { 
  return 1; 
}

int main() {
    A a;
    a.doit<float>();
}

In debug build, it prints out A, while in optimized build, it prints out here?\nB

I guess any inliner uses the generic template function definition but not the specialized one. But attribute ((noinline)) does not help.

Does anyone if my code has a defined behavior of C++? and how to fix this issue?

Joe C
  • 2,757
  • 2
  • 26
  • 46
  • My workaround I found is by inlining the specialized definitions: http://stackoverflow.com/questions/4445654/multiple-definition-of-template-specialization-when-using-different-objects. – Joe C May 03 '17 at 02:32

1 Answers1

2

You don't state this explicitly, but I'd guess in your actual code you were failing to declare the specialization in A's .h file. So when A.h was included in a separate compilation unit, the compiler was unaware of the specializatoin of WriteNative(). Adding a declaration of the specialization should fix the issue without having to include the definition in the same file (i.e., not having to inline it):

class A {
    public:
    template<typename T> int WriteNative(const T) { 
      printf("here?\n")
      return 0; 
    }

    template<typename D> 
        void doit() {
        if (WriteNative<double>(1)) {
            printf("A\n");
        } else {
            printf("B\n");
        }
    }
};
template<> int A::WriteNative(const double);

You can reproduce your issue by using three files A.h, A.cpp, and main.cpp, where A.cpp contains the definition of the specialization, so that when main.cpp includes A.h, it is unaware of the specialization when inlining happens during optimization, and when compiled with -O0, no inlining occurs, so WriteNative() gets linked against the definition in A.cpp.

Edit: See this answer which cites the spec to explain why this is correct behavior.

14.7.3 [temp.expl.spec]:

6/ If a template, a member template or a member of a class template is explicitly specialized then that specialization shall be declared before the first use of that specialization that would cause an implicit instantiation to take place, in every translation unit in which such a use occurs; no diagnostic is required. If the program does not provide a definition for an explicit specialization and either the specialization is used in a way that would cause an implicit instantiation to take place or the member is a virtual member function, the program is ill-formed, no diagnostic required. An implicit instantiation is never generated for an explicit specialization that is declared but not defined.

Community
  • 1
  • 1
dlasalle
  • 1,615
  • 3
  • 19
  • 25
  • Is declaring the specialization in the header file requested by C++? – Joe C May 03 '17 at 04:17
  • 1
    It is not. But then other compilation units will not see it, obviously. This is a matter of what happens during compilation and what happens during linkage – n.caillou May 03 '17 at 04:20
  • @n.caillou If it is not required, the optimization seems too aggressive to me. I think a compiler optimization should not change how code works unless my original code w/o the declaration is undefined. – Joe C May 03 '17 at 04:26
  • But your compiler doesn't know that an `A.cpp` file exists when it's compiling `main.o`. You're denying the entire per-unit compilation procedure. – n.caillou May 03 '17 at 04:38
  • I agree that with this assumption, more code can be optimized. However I think this is also similar to optimizing "bool b; b = false; if (b) ... " where b is a global. Compilers would not replace b by false because other files can "extern b" and assign other values to 'b'. How is this different from function template specialization? – Joe C May 03 '17 at 15:53