When to emit the vtable for a class template

When to emit the vtable for a class template

[Matt Austern]

I'm not sure whether the compiler is following what the ABI
specification (http://www.codesourcery.com/cxx-abi/abi.html)
says.  Entirely possible that I'm misunderstanding what the
ABI document is saying, of course.

The question: if you've got a polymorphic class template,
which translation units do you emit the vtable in?

5.2.3 says that you emit a vtable in the object file where you've
got the definition of the key function, or in every object file if
no key function exists.  5.2.3 may or may not apply to a class
template, of course.

5.2.7 seems to say that you emit a vtable for a class template
in every object file where the class template is instantiated,
irrespective of key functions.

What I'm not completely clear of is what exactly it means to
say that a class template is instantiated.  The most reasonable
interpretation is that the ABI specification is using this language
in the same sense of the C++ Standard, meaning that a class
template is instantiated "if the class type is used in a context that
requires a completely-defined object type or if the completeness
of the class type affects the semantics of the program".  Was that
the intention of the ABI specification and of the implementation?

			--Matt

Re: When to emit the vtable for a class template

[Matt Austern]

On Thursday, October 10, 2002, at 12:53 PM, Matt Austern wrote:

> I'm not sure whether the compiler is following what the ABI
> specification (http://www.codesourcery.com/cxx-abi/abi.html)
> says.  Entirely possible that I'm misunderstanding what the
> ABI document is saying, of course.
>
> The question: if you've got a polymorphic class template,
> which translation units do you emit the vtable in?
>
> 5.2.3 says that you emit a vtable in the object file where you've
> got the definition of the key function, or in every object file if
> no key function exists.  5.2.3 may or may not apply to a class
> template, of course.
>
> 5.2.7 seems to say that you emit a vtable for a class template
> in every object file where the class template is instantiated,
> irrespective of key functions.
>
> What I'm not completely clear of is what exactly it means to
> say that a class template is instantiated.  The most reasonable
> interpretation is that the ABI specification is using this language
> in the same sense of the C++ Standard, meaning that a class
> template is instantiated "if the class type is used in a context that
> requires a completely-defined object type or if the completeness
> of the class type affects the semantics of the program".  Was that
> the intention of the ABI specification and of the implementation?
>

Oh, and to follow up to myself...  If indeed (a) a vtable is to be
emitted in every translation unit where a polymorphic class
template is instantiated; and (b) "instantiated" is used in the
same sense as in clause 14 of the C++ Standard, then I've
found a case where it looks like that's not what's happening.
Consider the following translation unit:

     template<class T> struct X {
       virtual void foo();
       virtual ~X();
     };

     template <class T> void X<T>::foo() { }


     X<int>* xyzzy(X<int>* p) {
       return p + 1;
     }

Clearly X<int> must be instantiated.  However, compiling this
with -S and looking at the assembly code, I'm not seeing
X<int>'s vtable.

So, my question stands: under what circumstances does the
compiler emit a vtable for a polymorphic class template?  Is
the answer the same as what the ABI specification says it
should be?

			--Matt

Re: When to emit the vtable for a class template

[Gabriel Dos Reis]

Matt Austern <austern@apple.com> writes:

[...]

| Consider the following translation unit:
| 
|      template<class T> struct X {
|        virtual void foo();
|        virtual ~X();
|      };
| 
|      template <class T> void X<T>::foo() { }
| 
| 
|      X<int>* xyzzy(X<int>* p) {
|        return p + 1;
|      }
| 
| Clearly X<int> must be instantiated.

Hmm, if "instantiated" is used as the C++ standard uses it, then I'm
not clear why X<int> ought to be instantiated.  AFAIK, only the
template-id 'X<int>' needs to be "instantiated". 

Consider

   struct A;

   A* foo(X* p) { return p + 1; }

That is a valid construct that does not need completeness of type A and
the situation is not different from the X<int> case.

| However, compiling this
| with -S and looking at the assembly code, I'm not seeing
| X<int>'s vtable.

I fear the vtable for X<int> does not need to be emitted.

| So, my question stands: under what circumstances does the
| compiler emit a vtable for a polymorphic class template? 

I'm however unable to give an informed answer to this question.

| Is
| the answer the same as what the ABI specification says it
| should be?

I would expect so.

-- Gaby

Re: When to emit the vtable for a class template

[Matt Austern]

On Thursday, October 10, 2002, at 02:22 PM, Gabriel Dos Reis wrote:

> Matt Austern <austern@apple.com> writes:
>
> [...]
>
> | Consider the following translation unit:
> |
> |      template<class T> struct X {
> |        virtual void foo();
> |        virtual ~X();
> |      };
> |
> |      template <class T> void X<T>::foo() { }
> |
> |
> |      X<int>* xyzzy(X<int>* p) {
> |        return p + 1;
> |      }
> |
> | Clearly X<int> must be instantiated.
>
> Hmm, if "instantiated" is used as the C++ standard uses it, then I'm
> not clear why X<int> ought to be instantiated.  AFAIK, only the
> template-id 'X<int>' needs to be "instantiated".

5.7, paragraph 1: "For addition ... one operand shall be a pointer to
a completely defined object type and the other shall have integral
or enumeration type".  (Intuitively, X<int> needs to be complete for
pointer arithmetic to work because we need to know X<int>'s size.)

Since X<int> has to be a complete type, it follows from 14.7.1,
paragraphs 1 and 4, that this is an implicit instantiation of X<int>.

My (possibly incorrect) reading of the ABI specification is that an
implicit instantiation of a polymorphic class template results in
having its vtable emitted.

			--Matt

Re: When to emit the vtable for a class template

[Gabriel Dos Reis]

Matt Austern <austern@apple.com> writes:

| On Thursday, October 10, 2002, at 02:22 PM, Gabriel Dos Reis wrote:
| 
| > Matt Austern <austern@apple.com> writes:
| >
| > [...]
| >
| > | Consider the following translation unit:
| > |
| > |      template<class T> struct X {
| > |        virtual void foo();
| > |        virtual ~X();
| > |      };
| > |
| > |      template <class T> void X<T>::foo() { }
| > |
| > |
| > |      X<int>* xyzzy(X<int>* p) {
| > |        return p + 1;
| > |      }
| > |
| > | Clearly X<int> must be instantiated.
| >
| > Hmm, if "instantiated" is used as the C++ standard uses it, then I'm
| > not clear why X<int> ought to be instantiated.  AFAIK, only the
| > template-id 'X<int>' needs to be "instantiated".
| 
| 5.7, paragraph 1: "For addition ... one operand shall be a pointer to
| a completely defined object type and the other shall have integral
| or enumeration type".

Oops, I spoke non-sense.  Please, ignore my previous message -- I
should have rethought the issue before pressing the send key.

[...]

| My (possibly incorrect) reading of the ABI specification is that an
| implicit instantiation of a polymorphic class template results in
| having its vtable emitted.

I think your interpretation makes sense and you have a valid point.

-- Gaby