Re: [G++] templates not instantiated early enough

[Gabriel Dos Reis <gdr at integrable-solutions dot net>]

Chris Lattner <sabre@nondot.org> writes:

| On Thu, 3 Jun 2004, Andrew Pinski wrote:
| > On Jun 3, 2004, at 22:33, Chris Lattner wrote:
| > > The problem is that, in this testcase (which is reduced from a
| > > non-pointless larger testcase), the some_template is never instantiated
| > > with an int type.  This causes problems for my backend, which needs to
| > > look at the types for arguments for foo.  Currently, since the
| > > template is
| > > never being instantiated, the TYPE_SIZE and other fields are null.  The
| > > target that I'm working on specifically needs types laid out for
| > > function
| > > prototypes that take an aggregate value by value (as in this case).
| > > Pointers to templates can be lazily instantiated as needed.
| >
| > Why does it need them?  You should only need them for prototypes
| > which are used.
| 
| The problem is that the prototype *is* used.

So what?

Do you expect the compiler to reject the following fragment?

    stuct fu;

    void foo(fu);

    void bar() {
       foo;
    }
    

| In particular, the function 
| is mark_used and sent to the backend.  When the backend gets the prototype
| (through assemble_external or similar) it doesn't have the type
| information it needs for the instantiation of "some_template".  To emit

Replace some_template with "fu" as above.  And think about it.

| the prototype to the .s file, it needs information about structures passed
| by value to function prototypes, even if the function isn't even called
| (as in this case).

You have to design your backend so that it copes with that requirement
that a function signature needs not require a complete type if the it is
-not- used in a function definition or a function call.

| In this particular example, even if assemble_external is not used, the
| same problem occurs later when the function is expanded, so it's not
| specific to assemble_external/ASM_OUT_EXTERNAL.
| 
| > If you question is rather is the following valid code:
| > template<typename Ty>
| > struct some_template {typename Ty::t t;};
| >
| > void foo(some_template<int>  a);
| >
| > void (*f) (some_template<int>) = foo;
| >
| > As this case is where the template refers to an invalid type, int::t.
| 
| That's another great case that shows an example of this problem.  That
| should be flaged as an error and reported for the same reason that I'm
| having the problem.

Your "reason" is a problem in your backend.

-- Gaby