From: Jason Merrill <jason@yorick.cygnus.com>
Date: Thu, 23 Jul 1998 17:51:17 +0000 (+0000)
Subject: decl2.c (import_export_template): Fold in...
X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=7e7760939bf69c764707b32676784af383dacfd4;p=gcc.git

decl2.c (import_export_template): Fold in...

	* decl2.c (import_export_template): Fold in...
	(import_export_class): ...to here.  Handle dllimport/export.

From-SVN: r21350
---

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 06e62e57fd7..e26305ec2f0 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,5 +1,8 @@
 1998-07-23  Jason Merrill  <jason@yorick.cygnus.com>
 
+	* decl2.c (import_export_template): Fold in...
+	(import_export_class): ...to here.  Handle dllimport/export.
+
 	* class.c (build_vtable): Pass at_eof to import_export_vtable.
 	(prepare_fresh_vtable): Likewise.
 	* decl2.c (import_export_class): Split out...
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index b844355f0ff..c433e7ac9cf 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -2485,6 +2485,7 @@ extern void finish_builtin_type			PROTO((tree, char *, tree *, int, tree));
 extern tree coerce_new_type			PROTO((tree));
 extern tree coerce_delete_type			PROTO((tree));
 extern void comdat_linkage			PROTO((tree));
+extern void import_export_class			PROTO((tree));
 extern void import_export_vtable		PROTO((tree, tree, int));
 extern int finish_prevtable_vardecl		PROTO((tree, tree));
 extern int walk_vtables				PROTO((void (*)(tree, tree),
diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c
index 270c2fd9a15..901f5658722 100644
--- a/gcc/cp/decl2.c
+++ b/gcc/cp/decl2.c
@@ -52,7 +52,6 @@ static int cpp_initialized;
 
 static tree get_sentry PROTO((tree));
 static void mark_vtable_entries PROTO((tree));
-static void import_export_template PROTO((tree));
 static void grok_function_init PROTO((tree, tree));
 static int finish_vtable_vardecl PROTO((tree, tree));
 static int prune_vtable_vardecl PROTO((tree, tree));
@@ -2594,28 +2593,39 @@ import_export_vtable (decl, type, final)
     }
 }
 
-static void
-import_export_template (type)
-     tree type;
-{
-  if (CLASSTYPE_IMPLICIT_INSTANTIATION (type)
-      && ! flag_implicit_templates
-      && CLASSTYPE_INTERFACE_UNKNOWN (type))
-    {
-      SET_CLASSTYPE_INTERFACE_KNOWN (type);
-      CLASSTYPE_INTERFACE_ONLY (type) = 1;
-      CLASSTYPE_VTABLE_NEEDS_WRITING (type) = 0;
-    }
-}
+/* Determine whether or not we want to specifically import or export CTYPE,
+   using various heuristics.  */
 
 void
 import_export_class (ctype)
      tree ctype;
 {
-  import_export_template (ctype);
+  /* -1 for imported, 1 for exported.  */
+  int import_export = 0;
+
+  if (CLASSTYPE_INTERFACE_KNOWN (ctype))
+    return;
+
+#ifdef VALID_MACHINE_TYPE_ATTRIBUTE
+  /* FIXME this should really use some sort of target-independent macro.  */
+  if (lookup_attribute ("dllimport", TYPE_ATTRIBUTES (ctype)))
+    import_export = -1;
+  else if (lookup_attribute ("dllexport", TYPE_ATTRIBUTES (ctype)))
+    import_export = 1;
+#endif
+
+  /* If we got -fno-implicit-templates, we import template classes that
+     weren't explicitly instantiated.  */
+  if (import_export == 0
+      && CLASSTYPE_IMPLICIT_INSTANTIATION (ctype)
+      && ! flag_implicit_templates)
+    import_export = -1;
 
 #ifndef MULTIPLE_SYMBOL_SPACES
-  if (CLASSTYPE_INTERFACE_UNKNOWN (ctype) && TYPE_VIRTUAL_P (ctype)
+  /* Base our import/export status on that of the first non-inline,
+     non-abstract virtual function, if any.  */
+  if (import_export == 0
+      && TYPE_VIRTUAL_P (ctype)
       && ! CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
     {
       tree method;
@@ -2626,15 +2636,19 @@ import_export_class (ctype)
 	      && !DECL_THIS_INLINE (method)
 	      && !DECL_ABSTRACT_VIRTUAL_P (method))
 	    {
-	      SET_CLASSTYPE_INTERFACE_KNOWN (ctype);
-	      CLASSTYPE_VTABLE_NEEDS_WRITING (ctype)
-		= ! DECL_REALLY_EXTERN (method);
-	      CLASSTYPE_INTERFACE_ONLY (ctype) = DECL_REALLY_EXTERN (method);
+	      import_export = (DECL_REALLY_EXTERN (method) ? -1 : 1);
 	      break;
 	    }
 	}
     }
 #endif
+
+  if (import_export)
+    {
+      SET_CLASSTYPE_INTERFACE_KNOWN (ctype);
+      CLASSTYPE_VTABLE_NEEDS_WRITING (ctype) = (import_export > 0);
+      CLASSTYPE_INTERFACE_ONLY (ctype) = (import_export < 0);
+    }
 }
     
 int
@@ -2833,18 +2847,17 @@ import_export_decl (decl)
     {
       tree ctype = TREE_TYPE (DECL_NAME (decl));
       if (IS_AGGR_TYPE (ctype) && CLASSTYPE_INTERFACE_KNOWN (ctype)
-	  && TYPE_VIRTUAL_P (ctype))
-	{
+	  && TYPE_VIRTUAL_P (ctype)
 	  /* If the type is a cv-qualified variant of a type, then we
 	     must emit the tinfo function in this translation unit
 	     since it will not be emitted when the vtable for the type
 	     is output (which is when the unqualified version is
 	     generated).  */
+	  && ctype == TYPE_MAIN_VARIANT (ctype))
+	{
 	  DECL_NOT_REALLY_EXTERN (decl)
-	    = TYPE_READONLY (ctype) 
-	    || TYPE_VOLATILE (ctype)
-	    || ! (CLASSTYPE_INTERFACE_ONLY (ctype)
-		  || (DECL_THIS_INLINE (decl) && ! flag_implement_inlines));
+	    = ! (CLASSTYPE_INTERFACE_ONLY (ctype)
+		 || (DECL_THIS_INLINE (decl) && ! flag_implement_inlines));
 
 	  /* For WIN32 we also want to put explicit instantiations in
 	     linkonce sections.  */