OSDN Git Service

b4dbc3fb3c2f6d3e844151b13b62b3e73ed0864c
[pf3gnuchains/gcc-fork.git] / gcc / config / sh / symbian.c
1 /* Routines for GCC for a Symbian OS targeted SH backend.
2    Copyright (C) 2004, 2005, 2007, 2009 Free Software Foundation, Inc.
3    Contributed by RedHat.
4    Most of this code is stolen from i386/winnt.c.
5
6    This file is part of GCC.
7
8    GCC is free software; you can redistribute it and/or modify it
9    under the terms of the GNU General Public License as published
10    by the Free Software Foundation; either version 3, or (at your
11    option) any later version.
12
13    GCC is distributed in the hope that it will be useful, but WITHOUT
14    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
16    License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with GCC; see the file COPYING3.  If not see
20    <http://www.gnu.org/licenses/>.  */
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "rtl.h"
27 #include "output.h"
28 #include "flags.h"
29 #include "tree.h"
30 #include "expr.h"
31 #include "tm_p.h"
32 #include "cp/cp-tree.h" /* We need access to the OVL_... macros.  */
33 #include "toplev.h"
34
35 /* Select the level of debugging information to display.
36    0 for no debugging.
37    1 for informative messages about decisions to add attributes
38    2 for verbose information about what is being done.  */
39 #define SYMBIAN_DEBUG 0
40 /* #define SYMBIAN_DEBUG 1 */
41 /* #define SYMBIAN_DEBUG 2 */
42
43 /* A unique character to encode declspec encoded objects.  */
44 #define SH_SYMBIAN_FLAG_CHAR "$"
45
46 /* Unique strings to prefix exported and imported objects.  */
47 #define DLL_IMPORT_PREFIX SH_SYMBIAN_FLAG_CHAR "i."
48 #define DLL_EXPORT_PREFIX SH_SYMBIAN_FLAG_CHAR "e."
49
50 \f
51 /* Return the type that we should use to determine if DECL is
52    imported or exported.  */
53
54 static tree
55 sh_symbian_associated_type (tree decl)
56 {
57   tree t = NULL_TREE;
58
59   if (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
60   /* Methods now inherit their dllimport/dllexport attributes correctly
61      so there is no need to check their class.  In fact it is wrong to
62      check their class since a method can remain unexported from an
63      exported class.  */
64     return t;
65
66   /* Otherwise we can just take the DECL_CONTEXT as normal.  */
67   if (DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl)))
68     t = DECL_CONTEXT (decl);
69
70   return t;
71 }
72
73 /* Return nonzero if DECL is a dllexport'd object.  */
74
75 bool
76 sh_symbian_dllexport_p (tree decl)
77 {
78   tree exp;
79
80   if (   TREE_CODE (decl) != VAR_DECL
81       && TREE_CODE (decl) != FUNCTION_DECL)
82     return false;
83
84   exp = lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl));
85
86   /* Class members get the dllexport status of their class.  */
87   if (exp == NULL)
88     {
89       tree class = sh_symbian_associated_type (decl);
90
91       if (class)
92         exp = lookup_attribute ("dllexport", TYPE_ATTRIBUTES (class));
93     }
94 #if SYMBIAN_DEBUG
95   if (exp)
96     {
97       print_node_brief (stderr, "dllexport:", decl, 0);
98       fprintf (stderr, "\n");
99     }
100   else
101 #if SYMBIAN_DEBUG < 2
102     if (TREE_CODE (decl) != FUNCTION_DECL)
103 #endif
104     {
105       print_node_brief (stderr, "no dllexport:", decl, 0);
106       fprintf (stderr, "\n");
107     }
108 #endif
109   return exp ? true : false;
110 }
111
112 /* Return nonzero if DECL is a dllimport'd object.  */
113
114 static bool
115 sh_symbian_dllimport_p (tree decl)
116 {
117   tree imp;
118
119   if (   TREE_CODE (decl) != VAR_DECL
120       && TREE_CODE (decl) != FUNCTION_DECL)
121     return false;
122
123   imp = lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl));
124   if (imp)
125     return true;
126
127   /* Class members get the dllimport status of their class.  */
128   imp = sh_symbian_associated_type (decl);
129   if (! imp)
130     return false;
131
132   imp = lookup_attribute ("dllimport", TYPE_ATTRIBUTES (imp));
133   if (!imp)
134     return false;
135
136   /* Don't mark defined functions as dllimport.  If the definition itself
137      was marked with dllimport, then sh_symbian_handle_dll_attribute reports
138      an error. This handles the case when the definition overrides an
139      earlier declaration.  */
140   if (TREE_CODE (decl) ==  FUNCTION_DECL
141       && DECL_INITIAL (decl)
142       && ! DECL_DECLARED_INLINE_P (decl))
143     {
144       /* Don't warn about artificial methods.  */
145       if (!DECL_ARTIFICIAL (decl))
146         warning (OPT_Wattributes, "function %q+D is defined after prior "
147                  "declaration as dllimport: attribute ignored",
148                  decl);
149       return false;
150     }
151
152   /* We ignore the dllimport attribute for inline member functions.
153      This differs from MSVC behavior which treats it like GNUC
154      'extern inline' extension.   */
155   else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl))
156     {
157       if (extra_warnings)
158         warning (OPT_Wattributes, "inline function %q+D is declared as "
159                  "dllimport: attribute ignored",
160                  decl);
161       return false;
162     }
163
164   /*  Don't allow definitions of static data members in dllimport
165       class.  Just ignore the attribute for vtable data.  */
166   else if (TREE_CODE (decl) == VAR_DECL
167            && TREE_STATIC (decl)
168            && TREE_PUBLIC (decl)
169            && !DECL_EXTERNAL (decl))
170     {
171       if (!DECL_VIRTUAL_P (decl))
172         error ("definition of static data member %q+D of dllimport'd class",
173                decl);
174       return false;
175     }
176
177   /* Since we can't treat a pointer to a dllimport'd symbol as a
178      constant address, we turn off the attribute on C++ virtual
179      methods to allow creation of vtables using thunks.  Don't mark
180      artificial methods either (in sh_symbian_associated_type, only
181      COMDAT artificial method get import status from class context).  */
182   else if (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE
183            && (DECL_VIRTUAL_P (decl) || DECL_ARTIFICIAL (decl)))
184     return false;
185
186   return true;
187 }
188
189 /* Return nonzero if SYMBOL is marked as being dllexport'd.  */
190
191 bool
192 sh_symbian_dllexport_name_p (const char *symbol)
193 {
194   return strncmp (DLL_EXPORT_PREFIX, symbol,
195                   strlen (DLL_EXPORT_PREFIX)) == 0;
196 }
197
198 /* Return nonzero if SYMBOL is marked as being dllimport'd.  */
199
200
201 bool
202 sh_symbian_dllimport_name_p (const char *symbol)
203 {
204   return strncmp (DLL_IMPORT_PREFIX, symbol,
205                   strlen (DLL_IMPORT_PREFIX)) == 0;
206 }
207
208 /* Mark a DECL as being dllexport'd.
209    Note that we override the previous setting (e.g.: dllimport).  */
210
211 static void
212 sh_symbian_mark_dllexport (tree decl)
213 {
214   const char *oldname;
215   char *newname;
216   rtx rtlname;
217   tree idp;
218
219   rtlname = XEXP (DECL_RTL (decl), 0);
220   if (MEM_P (rtlname))
221     rtlname = XEXP (rtlname, 0);
222   gcc_assert (GET_CODE (rtlname) == SYMBOL_REF);
223   oldname = XSTR (rtlname, 0);
224
225   if (sh_symbian_dllimport_name_p (oldname))
226     {
227      /* Remove DLL_IMPORT_PREFIX.
228         Note - we do not issue a warning here.  In Symbian's environment it
229         is legitimate for a prototype to be marked as dllimport and the
230         corresponding definition to be marked as dllexport.  The prototypes
231         are in headers used everywhere and the definition is in a translation
232         unit which has included the header in order to ensure argument
233         correctness.  */
234       oldname += strlen (DLL_IMPORT_PREFIX);
235       DECL_DLLIMPORT_P (decl) = 0;
236     }
237   else if (sh_symbian_dllexport_name_p (oldname))
238     return; /* Already done.  */
239
240   newname = alloca (strlen (DLL_EXPORT_PREFIX) + strlen (oldname) + 1);
241   sprintf (newname, "%s%s", DLL_EXPORT_PREFIX, oldname);
242
243   /* We pass newname through get_identifier to ensure it has a unique
244      address.  RTL processing can sometimes peek inside the symbol ref
245      and compare the string's addresses to see if two symbols are
246      identical.  */
247   idp = get_identifier (newname);
248
249   XEXP (DECL_RTL (decl), 0) =
250     gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (idp));
251 }
252
253 /* Mark a DECL as being dllimport'd.  */
254
255 static void
256 sh_symbian_mark_dllimport (tree decl)
257 {
258   const char *oldname;
259   char *newname;
260   tree idp;
261   rtx rtlname;
262   rtx newrtl;
263
264   rtlname = XEXP (DECL_RTL (decl), 0);
265   if (MEM_P (rtlname))
266     rtlname = XEXP (rtlname, 0);
267   gcc_assert (GET_CODE (rtlname) == SYMBOL_REF);
268   oldname = XSTR (rtlname, 0);
269
270   if (sh_symbian_dllexport_name_p (oldname))
271     {
272       error ("%qE declared as both exported to and imported from a DLL",
273              DECL_NAME (decl));
274     }
275   else if (sh_symbian_dllimport_name_p (oldname))
276     {
277       /* Already done, but do a sanity check to prevent assembler errors.  */
278       if (!DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl))
279         error ("failure in redeclaration of %q+D: dllimport'd symbol lacks external linkage",
280                decl);
281     }
282   else
283     {
284       newname = alloca (strlen (DLL_IMPORT_PREFIX) + strlen (oldname) + 1);
285       sprintf (newname, "%s%s", DLL_IMPORT_PREFIX, oldname);
286
287       /* We pass newname through get_identifier to ensure it has a unique
288          address.  RTL processing can sometimes peek inside the symbol ref
289          and compare the string's addresses to see if two symbols are
290          identical.  */
291       idp = get_identifier (newname);
292       newrtl = gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (idp));
293       XEXP (DECL_RTL (decl), 0) = newrtl;
294     }
295 }
296
297 void
298 sh_symbian_encode_section_info (tree decl, rtx rtl, int first)
299 {
300   default_encode_section_info (decl, rtl, first);
301
302   /* Mark the decl so we can tell from the rtl whether
303      the object is dllexport'd or dllimport'd.  */
304   if (sh_symbian_dllexport_p (decl))
305     sh_symbian_mark_dllexport (decl);
306   else if (sh_symbian_dllimport_p (decl))
307     sh_symbian_mark_dllimport (decl);
308   /* It might be that DECL has already been marked as dllimport, but a
309      subsequent definition nullified that.  The attribute is gone but
310      DECL_RTL still has (DLL_IMPORT_PREFIX) prefixed. We need to remove
311      that. Ditto for the DECL_DLLIMPORT_P flag.  */
312   else if (  (TREE_CODE (decl) == FUNCTION_DECL
313            || TREE_CODE (decl) == VAR_DECL)
314            && DECL_RTL (decl) != NULL_RTX
315            && MEM_P (DECL_RTL (decl))
316            && MEM_P (XEXP (DECL_RTL (decl), 0))
317            && GET_CODE (XEXP (XEXP (DECL_RTL (decl), 0), 0)) == SYMBOL_REF
318            && sh_symbian_dllimport_name_p (XSTR (XEXP (XEXP (DECL_RTL (decl), 0), 0), 0)))
319     {
320       const char * oldname = XSTR (XEXP (XEXP (DECL_RTL (decl), 0), 0), 0);
321       /* Remove DLL_IMPORT_PREFIX.  */
322       tree idp = get_identifier (oldname + strlen (DLL_IMPORT_PREFIX));
323       rtx newrtl = gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (idp));
324
325       warning (0, "%s %q+D %s after being referenced with dllimport linkage",
326                TREE_CODE (decl) == VAR_DECL ? "variable" : "function",
327                decl, (DECL_INITIAL (decl) || !DECL_EXTERNAL (decl))
328                ? "defined locally" : "redeclared without dllimport attribute");
329
330       XEXP (DECL_RTL (decl), 0) = newrtl;
331
332       DECL_DLLIMPORT_P (decl) = 0;
333     }
334 }
335
336
337 /* Return the length of a function name prefix
338     that starts with the character 'c'.  */
339
340 static int
341 sh_symbian_get_strip_length (int c)
342 {
343   /* XXX Assumes strlen (DLL_EXPORT_PREFIX) == strlen (DLL_IMPORT_PREFIX).  */
344   return (c == SH_SYMBIAN_FLAG_CHAR[0]) ? strlen (DLL_EXPORT_PREFIX) : 0;
345 }
346
347 /* Return a pointer to a function's name with any
348    and all prefix encodings stripped from it.  */
349
350 const char *
351 sh_symbian_strip_name_encoding (const char *name)
352 {
353   int skip;
354
355   while ((skip = sh_symbian_get_strip_length (*name)))
356     name += skip;
357
358   return name;
359 }
360
361 /* Add the named attribute to the given node.  Copes with both DECLs and
362    TYPEs.  Will only add the attribute if it is not already present.  */
363
364 static void
365 symbian_add_attribute (tree node, const char *attr_name)
366 {
367   tree attrs;
368   tree attr;
369
370   attrs = DECL_P (node) ? DECL_ATTRIBUTES (node) : TYPE_ATTRIBUTES (node);
371
372   if (lookup_attribute (attr_name, attrs) != NULL_TREE)
373     return;
374
375   attr = get_identifier (attr_name);
376
377   if (DECL_P (node))
378     DECL_ATTRIBUTES (node) = tree_cons (attr, NULL_TREE, attrs);
379   else
380     TYPE_ATTRIBUTES (node) = tree_cons (attr, NULL_TREE, attrs);
381
382 #if SYMBIAN_DEBUG
383   fprintf (stderr, "propagate %s attribute", attr_name);
384   print_node_brief (stderr, " to", node, 0);
385   fprintf (stderr, "\n");
386 #endif
387 }
388
389 /* Handle a "dllimport" or "dllexport" attribute;
390    arguments as in struct attribute_spec.handler.  */
391
392 tree
393 sh_symbian_handle_dll_attribute (tree *pnode, tree name, tree args,
394                                  int flags, bool *no_add_attrs)
395 {
396   tree thunk;
397   tree node = *pnode;
398   const char *attr = IDENTIFIER_POINTER (name);
399
400   /* These attributes may apply to structure and union types being
401      created, but otherwise should pass to the declaration involved.  */
402   if (!DECL_P (node))
403     {
404       if (flags & ((int) ATTR_FLAG_DECL_NEXT
405                    | (int) ATTR_FLAG_FUNCTION_NEXT
406                    | (int) ATTR_FLAG_ARRAY_NEXT))
407         {
408           warning (OPT_Wattributes, "%qs attribute ignored", attr);
409           *no_add_attrs = true;
410           return tree_cons (name, args, NULL_TREE);
411         }
412
413       if (TREE_CODE (node) != RECORD_TYPE && TREE_CODE (node) != UNION_TYPE)
414         {
415           warning (OPT_Wattributes, "%qs attribute ignored", attr);
416           *no_add_attrs = true;
417         }
418
419       return NULL_TREE;
420     }
421
422   /* Report error on dllimport ambiguities
423      seen now before they cause any damage.  */
424   else if (is_attribute_p ("dllimport", name))
425     {
426       if (TREE_CODE (node) == VAR_DECL)
427         {
428           if (DECL_INITIAL (node))
429             {
430               error ("variable %q+D definition is marked dllimport",
431                      node);
432               *no_add_attrs = true;
433             }
434
435           /* `extern' needn't be specified with dllimport.
436              Specify `extern' now and hope for the best.  Sigh.  */
437           DECL_EXTERNAL (node) = 1;
438           /* Also, implicitly give dllimport'd variables declared within
439              a function global scope, unless declared static.  */
440           if (current_function_decl != NULL_TREE && ! TREE_STATIC (node))
441             TREE_PUBLIC (node) = 1;
442         }
443     }
444
445   /* If the node is an overloaded constructor or destructor, then we must
446      make sure that the attribute is propagated along the overload chain,
447      as it is these overloaded functions which will be emitted, rather than
448      the user declared constructor itself.  */
449   if (TREE_CODE (TREE_TYPE (node)) == METHOD_TYPE
450       && (DECL_CONSTRUCTOR_P (node) || DECL_DESTRUCTOR_P (node)))
451     {
452       tree overload;
453
454       for (overload = OVL_CHAIN (node); overload; overload = OVL_CHAIN (overload))
455         {
456           tree node_args;
457           tree func_args;
458           tree function = OVL_CURRENT (overload);
459
460           if (! function
461               || ! DECL_P (function)
462               || (DECL_CONSTRUCTOR_P (node) && ! DECL_CONSTRUCTOR_P (function))
463               || (DECL_DESTRUCTOR_P (node)  && ! DECL_DESTRUCTOR_P (function)))
464             continue;
465
466           /* The arguments must match as well.  */
467           for (node_args = DECL_ARGUMENTS (node), func_args = DECL_ARGUMENTS (function);
468                node_args && func_args;
469                node_args = TREE_CHAIN (node_args), func_args = TREE_CHAIN (func_args))
470             if (TREE_TYPE (node_args) != TREE_TYPE (func_args))
471               break;
472
473           if (node_args || func_args)
474             {
475               /* We can ignore an extraneous __in_chrg arguments in the node.
476                  GCC generated destructors, for example, will have this.  */
477               if ((node_args == NULL_TREE
478                    || func_args != NULL_TREE)
479                   && strcmp (IDENTIFIER_POINTER (DECL_NAME (node)), "__in_chrg") != 0)
480                 continue;
481             }
482
483           symbian_add_attribute (function, attr);
484
485           /* Propagate the attribute to any function thunks as well.  */
486           for (thunk = DECL_THUNKS (function); thunk; thunk = TREE_CHAIN (thunk))
487             if (TREE_CODE (thunk) == FUNCTION_DECL)
488               symbian_add_attribute (thunk, attr);
489         }
490     }
491
492   if (TREE_CODE (node) == FUNCTION_DECL && DECL_VIRTUAL_P (node))
493     {
494       /* Propagate the attribute to any thunks of this function.  */
495       for (thunk = DECL_THUNKS (node); thunk; thunk = TREE_CHAIN (thunk))
496         if (TREE_CODE (thunk) == FUNCTION_DECL)
497           symbian_add_attribute (thunk, attr);
498     }
499
500   /*  Report error if symbol is not accessible at global scope.  */
501   if (!TREE_PUBLIC (node)
502       && (   TREE_CODE (node) == VAR_DECL
503           || TREE_CODE (node) == FUNCTION_DECL))
504     {
505       error ("external linkage required for symbol %q+D because of %qE attribute",
506              node, name);
507       *no_add_attrs = true;
508     }
509
510 #if SYMBIAN_DEBUG
511   print_node_brief (stderr, "mark node", node, 0);
512   fprintf (stderr, " as %s\n", attr);
513 #endif
514
515   return NULL_TREE;
516 }
517
518 /* This code implements a specification for exporting the vtable and rtti of
519    classes that have members with the dllexport or dllexport attributes.
520    This specification is defined here:
521
522      http://www.armdevzone.com/EABI/exported_class.txt
523
524    Basically it says that a class's vtable and rtti should be exported if
525    the following rules apply:
526
527    - If it has any non-inline non-pure virtual functions,
528      at least one of these need to be declared dllimport
529      OR any of the constructors is declared dllimport.
530
531    AND
532
533    - The class has an inline constructor/destructor and
534      a key-function (placement of vtable uniquely defined) that
535      is defined in this translation unit.
536
537    The specification also says that for classes which will have their
538    vtables and rtti exported that their base class(es) might also need a
539    similar exporting if:
540
541    - Every base class needs to have its vtable & rtti exported
542      as well, if the following the conditions hold true:
543      + The base class has a non-inline declared non-pure virtual function
544      + The base class is polymorphic (has or inherits any virtual functions)
545        or the base class has any virtual base classes.  */
546 \f
547 /* Decide if a base class of a class should
548    also have its vtable and rtti exported.  */
549
550 static void
551 symbian_possibly_export_base_class (tree base_class)
552 {
553   VEC(tree,gc) *method_vec;
554   int len;
555
556   if (! (TYPE_CONTAINS_VPTR_P (base_class)))
557     return;
558
559   method_vec = CLASSTYPE_METHOD_VEC (base_class);
560   len = method_vec ? VEC_length (tree, method_vec) : 0;
561
562   for (;len --;)
563     {
564       tree member = VEC_index (tree, method_vec, len);
565
566       if (! member)
567         continue;
568
569       for (member = OVL_CURRENT (member); member; member = OVL_NEXT (member))
570         {
571           if (TREE_CODE (member) != FUNCTION_DECL)
572             continue;
573
574           if (DECL_CONSTRUCTOR_P (member) || DECL_DESTRUCTOR_P (member))
575             continue;
576
577           if (! DECL_VIRTUAL_P (member))
578             continue;
579
580           if (DECL_PURE_VIRTUAL_P (member))
581             continue;
582
583           if (DECL_DECLARED_INLINE_P (member))
584             continue;
585
586           break;
587         }
588
589       if (member)
590         break;
591     }
592
593   if (len < 0)
594     return;
595
596   /* FIXME: According to the spec this base class should be exported, but
597      a) how do we do this ? and
598      b) it does not appear to be necessary for compliance with the Symbian
599         OS which so far is the only consumer of this code.  */
600 #if SYMBIAN_DEBUG
601   print_node_brief (stderr, "", base_class, 0);
602   fprintf (stderr, " EXPORTed [base class of exported class]\n");
603 #endif
604 }
605
606 /* Decide if a class needs its vtable and rtti exporting.  */
607
608 static bool
609 symbian_export_vtable_and_rtti_p (tree ctype)
610 {
611   bool inline_ctor_dtor;
612   bool dllimport_ctor_dtor;
613   bool dllimport_member;
614   tree binfo, base_binfo;
615   VEC(tree,gc) *method_vec;
616   tree key;
617   int i;
618   int len;
619
620   /* Make sure that we are examining a class...  */
621   if (TREE_CODE (ctype) != RECORD_TYPE)
622     {
623 #if SYMBIAN_DEBUG
624       print_node_brief (stderr, "", ctype, 0);
625       fprintf (stderr, " does NOT need to be EXPORTed [not a class]\n");
626 #endif
627       return false;
628     }
629
630   /* If the class does not have a key function it
631      does not need to have its vtable exported.  */
632   if ((key = CLASSTYPE_KEY_METHOD (ctype)) == NULL_TREE)
633     {
634 #if SYMBIAN_DEBUG
635       print_node_brief (stderr, "", ctype, 0);
636       fprintf (stderr, " does NOT need to be EXPORTed [no key function]\n");
637 #endif
638       return false;
639     }
640
641   /* If the key fn has not been defined
642      then the class should not be exported.  */
643   if (! TREE_ASM_WRITTEN (key))
644     {
645 #if SYMBIAN_DEBUG
646       print_node_brief (stderr, "", ctype, 0);
647       fprintf (stderr, " does NOT need to be EXPORTed [key function not defined]\n");
648 #endif
649       return false;
650     }
651
652   /* Check the class's member functions.  */
653   inline_ctor_dtor = false;
654   dllimport_ctor_dtor = false;
655   dllimport_member = false;
656
657   method_vec = CLASSTYPE_METHOD_VEC (ctype);
658   len = method_vec ? VEC_length (tree, method_vec) : 0;
659
660   for (;len --;)
661     {
662       tree member = VEC_index (tree, method_vec, len);
663
664       if (! member)
665         continue;
666
667       for (member = OVL_CURRENT (member); member; member = OVL_NEXT (member))
668         {
669           if (TREE_CODE (member) != FUNCTION_DECL)
670             continue;
671
672           if (DECL_CONSTRUCTOR_P (member) || DECL_DESTRUCTOR_P (member))
673             {
674               if (DECL_DECLARED_INLINE_P (member)
675                   /* Ignore C++ backend created inline ctors/dtors.  */
676                   && (   DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (member)
677                       || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (member)))
678                 inline_ctor_dtor = true;
679
680               if (lookup_attribute ("dllimport", DECL_ATTRIBUTES (member)))
681                 dllimport_ctor_dtor = true;
682             }
683           else
684             {
685               if (DECL_PURE_VIRTUAL_P (member))
686                 continue;
687
688               if (! DECL_VIRTUAL_P (member))
689                 continue;
690
691               if (DECL_DECLARED_INLINE_P (member))
692                 continue;
693
694               if (lookup_attribute ("dllimport", DECL_ATTRIBUTES (member)))
695                 dllimport_member = true;
696             }
697         }
698     }
699
700   if (! dllimport_member && ! dllimport_ctor_dtor)
701     {
702 #if SYMBIAN_DEBUG
703       print_node_brief (stderr, "", ctype, 0);
704       fprintf (stderr,
705                " does NOT need to be EXPORTed [no non-pure virtuals or ctors/dtors with dllimport]\n");
706 #endif
707       return false;
708     }
709
710   if (! inline_ctor_dtor)
711     {
712 #if SYMBIAN_DEBUG
713       print_node_brief (stderr, "", ctype, 0);
714       fprintf (stderr,
715                " does NOT need to be EXPORTed [no inline ctor/dtor]\n");
716 #endif
717       return false;
718     }
719
720 #if SYMBIAN_DEBUG
721   print_node_brief (stderr, "", ctype, 0);
722   fprintf (stderr, " DOES need to be EXPORTed\n");
723 #endif
724
725   /* Now we must check and possibly export the base classes.  */
726   for (i = 0, binfo = TYPE_BINFO (ctype);
727        BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
728     symbian_possibly_export_base_class (BINFO_TYPE (base_binfo));
729
730   return true;
731 }
732
733 /* Add the named attribute to a class and its vtable and rtti.  */
734
735 static void
736 symbian_add_attribute_to_class_vtable_and_rtti (tree ctype, const char *attr_name)
737 {
738   symbian_add_attribute (ctype, attr_name);
739
740   /* If the vtable exists then they need annotating as well.  */
741   if (CLASSTYPE_VTABLES (ctype))
742     /* XXX - Do we need to annotate any vtables other than the primary ?  */
743     symbian_add_attribute (CLASSTYPE_VTABLES (ctype), attr_name);
744
745   /* If the rtti exists then it needs annotating as well.  */
746   if (TYPE_MAIN_VARIANT (ctype)
747       && CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (ctype)))
748     symbian_add_attribute (CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (ctype)),
749                            attr_name);
750 }
751
752 /* Decide if a class needs to have an attribute because
753    one of its member functions has the attribute.  */
754
755 static bool
756 symbian_class_needs_attribute_p (tree ctype, const char *attribute_name)
757 {
758   VEC(tree,gc) *method_vec;
759
760   method_vec = CLASSTYPE_METHOD_VEC (ctype);
761
762   /* If the key function has the attribute then the class needs it too.  */
763   if (TYPE_POLYMORPHIC_P (ctype)
764       && method_vec
765       && lookup_attribute (attribute_name,
766                            DECL_ATTRIBUTES (VEC_index (tree, method_vec, 0))))
767     return true;
768
769   /* Check the class's member functions.  */
770   if (TREE_CODE (ctype) == RECORD_TYPE)
771     {
772       unsigned int len;
773
774       len = method_vec ? VEC_length (tree, method_vec) : 0;
775
776       for (;len --;)
777         {
778           tree member = VEC_index (tree, method_vec, len);
779
780           if (! member)
781             continue;
782
783           for (member = OVL_CURRENT (member);
784                member;
785                member = OVL_NEXT (member))
786             {
787               if (TREE_CODE (member) != FUNCTION_DECL)
788                 continue;
789
790               if (DECL_PURE_VIRTUAL_P (member))
791                 continue;
792
793               if (! DECL_VIRTUAL_P (member))
794                 continue;
795
796               if (lookup_attribute (attribute_name, DECL_ATTRIBUTES (member)))
797                 {
798 #if SYMBIAN_DEBUG
799                   print_node_brief (stderr, "", ctype, 0);
800                   fprintf (stderr, " inherits %s because", attribute_name);
801                   print_node_brief (stderr, "", member, 0);
802                   fprintf (stderr, " has it.\n");
803 #endif
804                   return true;
805                 }
806             }
807         }
808     }
809
810 #if SYMBIAN_DEBUG
811   print_node_brief (stderr, "", ctype, 0);
812   fprintf (stderr, " does not inherit %s\n", attribute_name);
813 #endif
814   return false;
815 }
816
817 int
818 symbian_import_export_class (tree ctype, int import_export)
819 {
820   const char *attr_name = NULL;
821
822   /* If we are exporting the class but it does not have the dllexport
823      attribute then we may need to add it.  Similarly imported classes
824      may need the dllimport attribute.  */
825   switch (import_export)
826     {
827     case  1: attr_name = "dllexport"; break;
828     case -1: attr_name = "dllimport"; break;
829     default: break;
830     }
831
832   if (attr_name
833       && ! lookup_attribute (attr_name, TYPE_ATTRIBUTES (ctype)))
834     {
835       if (symbian_class_needs_attribute_p (ctype, attr_name))
836         symbian_add_attribute_to_class_vtable_and_rtti (ctype, attr_name);
837
838       /* Classes can be forced to export their
839          vtable and rtti under certain conditions.  */
840       if (symbian_export_vtable_and_rtti_p (ctype))
841         {
842           symbian_add_attribute_to_class_vtable_and_rtti (ctype, "dllexport");
843
844           /* Make sure that the class and its vtable are exported.  */
845           import_export = 1;
846
847           if (CLASSTYPE_VTABLES (ctype))
848             DECL_EXTERNAL (CLASSTYPE_VTABLES (ctype)) = 1;
849
850           /* Check to make sure that if the class has a key method that
851              it is now on the list of keyed classes.  That way its vtable
852              will be emitted.  */
853           if (CLASSTYPE_KEY_METHOD (ctype))
854             {
855               tree class;
856
857               for (class = keyed_classes; class; class = TREE_CHAIN (class))
858                 if (class == ctype)
859                   break;
860
861               if (class == NULL_TREE)
862                 {
863 #if SYMBIAN_DEBUG
864                   print_node_brief (stderr, "Add node", ctype, 0);
865                   fprintf (stderr, " to the keyed classes list\n");
866 #endif
867                   keyed_classes = tree_cons (NULL_TREE, ctype, keyed_classes);
868                 }
869             }
870
871           /* Make sure that the typeinfo will be emitted as well.  */
872           if (CLASS_TYPE_P (ctype))
873             TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (ctype)))) = 1;
874         }
875     }
876
877   return import_export;
878 }
879
880 /* Dummy definition of this array for cc1 building purposes.  */
881 tree cp_global_trees[CPTI_MAX] __attribute__((weak));
882
883 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
884
885 /* Dummy version of this G++ function for building cc1.  */
886 void lang_check_failed (const char *, int, const char *) __attribute__((weak));
887
888 void
889 lang_check_failed (const char *file, int line, const char *function)
890 {
891   internal_error ("lang_* check: failed in %s, at %s:%d",
892                   function, trim_filename (file), line);
893 }
894 #endif /* ENABLE_TREE_CHECKING */