[RFH] C++ FE question

[Josh Conner]

I've been looking at PR23708, where a non-inline explicitly  
specialized template function is inheriting the inline semantics of  
the inline member function it specializes, when using pre-compiled  
headers (whew).  This can be seen in the following example:

     template <class T> class simple_class {
       public:
         inline void testfn (T);
     };

     template <> void simple_class<int>::testfn (int) {}  //  
incorrectly inheriting 'inline' semantics when using PCH

Where the specialization function ends up in a COMDAT section.

I have some understanding on why this is happening, but could use a  
little help in fixing the problem.  If I compile the example above  
into a precompiled header, the sequence of events is as follows:

   simple_class<T>::testfn is generated
   simple_class<T>::testfn is assigned to the COMDAT section by  
note_decl_for_pch()
   simple_class<int>::testfn (implicit instantiation) is generated,  
which inherits the COMDAT-ness from simple_class<T>::testfn
   simple_class<int>::testfn (explicit specialization) is generated
   simple_class<int>::testfn (explicit specialization) is assigned to  
the COMDAT section by duplicate_decls(), when it merges the  
declarations with the implicit instantiation

When not using precompiled headers, the sequence is this:

   simple_class<T>::testfn is generated
   simple_class<int>::testfn (implicit) is generated
   simple_class<int>::testfn (explicit) is generated
   simple_class<T>::testfn is assigned to the COMDAT section
   simple_class<int>::testfn (implicit) is assigned to the COMDAT  
section

My first approach was to modify duplicate_decls() so it wouldn't copy  
the COMDAT-ness into the explicit specialization, the same way that  
we avoid copying the DECL_DECLARED_INLINE_P.  This worked for my  
particular instance, however because COMDAT implementation is host- 
dependent, it seems very dangerous.

My second approach is to disable the code in note_decl_for_pch() that  
assigns COMDAT-ness early.  This works, too, but it would be nice to  
not lose the advantage that this code was put in for.

So, my third approach was to modify note_decl_for_pch() to filter out  
simple_class<T>::testfn, similarly to how the implicit <int>  
declaration is filtered out.  However, in order to do so, I need to  
detect that simple_class<T>::testfn is a member function of a  
template class.  But how do I do this?  I can detect which class the  
function is a member of by looking at DECL_CONTEXT, but I don't see  
how to determine if this class is a template class.  Is there a way  
to find the class type tree from the FUNCTION_DECL?  I can get see  
the type information I want at DECL_CONTEXT(decl)->common.chain in  
the debugger, but I have no reason to believe that this is the  
correct way to get it, or that it will work all of the time.

Does anyone have any suggestions on:
a) whether I'm headed in the right direction, and
b) if so, how to determine that simple_class<T>::testfn is a member  
of a template class, and not an instantiated class?

Thanks -

Josh