Changeset 2003

Timestamp:

Jun 6, 2005, 4:43:42 AM (20 years ago)

Author:

bird

Message:

declspec(dllexport,dllimport,shared) - only dllexport is doing something useful.

Location:

trunk/src/gcc/gcc/config/i386

Files:

• emx-libgcc_so_d.def (modified) (1 diff, 1 prop)
• emx.c (modified) (4 diffs, 1 prop)
• emx.h (modified) (10 diffs, 1 prop)

trunk/src/gcc/gcc/config/i386/emx-libgcc_so_d.def ¶

@@ -1 +1 @@
 ; Auto-generated file, DO NOT EDIT!!! (see libgcc_d.awk) */
-LIBRARY libc06b2 INITINSTANCE TERMINSTANCE
+LIBRARY libc06b5 INITINSTANCE TERMINSTANCE
 EXPORTS
 EXPORTS

trunk/src/gcc/gcc/config/i386/emx.c ¶

@@ -126 +126 @@
 
 int emx_c_set_decl_assembler_name (decl, fclass)
-    tree decl; 
+    tree decl;
     int fclass;
 {
@@ -135 +135 @@
   tree id, type;
   int rc = 1;
-  
+
   /*
   dfprintf((stderr, "emx_c_set_decl_assembler_name\n"));
@@ -429 +429 @@
 /* Checks if the function is using either optlink or system calling convention
    and returns 1 in those cases forcing the return value to be in memory.
-   The problem (#631) was that structures less than 8 bytes were returned in 
+   The problem (#631) was that structures less than 8 bytes were returned in
    registers. _System and _Optlink requires them to be passed in as a hidden
    parameter.
@@ -477 +477 @@
 }
 
-/* Strip the no-underscore prefix. 
-  Also strip the stdcall suffix.  */
-const char * emx_strip_name_encoding_full (str)
+/* Strip only the leading encoding, leaving the stdcall suffix.  */
+
+const char *
+i386_emx_strip_name_encoding (str)
     const char *str;
 {
-  const char *p;
+  if (*str == DLL_IMPORT_EXPORT_PREFIX)
+    str += 3;
   if (*str == '%')                      /* don't actually know what this is.. */
     str += 2;
   if (*str == '*')
     str += 1;
-
-  /* stdcall */
-  p = strchr (str, '@');
+  return str;
+}
+
+/* Also strip the stdcall suffix.  */
+
+const char * emx_strip_name_encoding_full (str)
+    const char *str;
+{
+  const char *p;
+  const char *name = i386_emx_strip_name_encoding (str);
+
+  p = strchr (name, '@');
   if (p)
-    return ggc_alloc_string (str, p - str);
-
-  return str;
-}
-
+    return ggc_alloc_string (name, p - name);
+
+  return name;
+}
+
+
+/* copy&hack from winnt.c */
+
+static tree associated_type PARAMS ((tree));
+/*static const char * gen_stdcall_suffix PARAMS ((tree));*/
+static int i386_emx_dllexport_p PARAMS ((tree));
+static int i386_emx_dllimport_p PARAMS ((tree));
+static void i386_emx_mark_dllexport PARAMS ((tree));
+static void i386_emx_mark_dllimport PARAMS ((tree));
+
+/* Handle a "dllimport" or "dllexport" attribute;
+   arguments as in struct attribute_spec.handler.  */
+tree
+ix86_handle_dll_attribute (pnode, name, args, flags, no_add_attrs)
+     tree * pnode;
+     tree name;
+     tree args;
+     int flags;
+     bool *no_add_attrs;
+{
+  tree node = *pnode;
+
+  /* These attributes may apply to structure and union types being created,
+     but otherwise should pass to the declaration involved.  */
+  if (!DECL_P (node))
+    {
+      if (flags & ((int) ATTR_FLAG_DECL_NEXT | (int) ATTR_FLAG_FUNCTION_NEXT
+                   | (int) ATTR_FLAG_ARRAY_NEXT))
+        {
+          *no_add_attrs = true;
+          return tree_cons (name, args, NULL_TREE);
+        }
+      if (TREE_CODE (node) != RECORD_TYPE && TREE_CODE (node) != UNION_TYPE)
+        {
+          warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
+          *no_add_attrs = true;
+        }
+
+      return NULL_TREE;
+    }
+
+  /* Report error on dllimport ambiguities seen now before they cause
+     any damage.  */
+  else if (is_attribute_p ("dllimport", name))
+    {
+      /* Like MS, treat definition of dllimported variables and
+         non-inlined functions on declaration as syntax errors.
+         We allow the attribute for function definitions if declared
+         inline, but just ignore it in i386_emx_dllimport_p.  */
+      if (TREE_CODE (node) == FUNCTION_DECL  && DECL_INITIAL (node)
+          && !DECL_INLINE (node))
+        {
+          error_with_decl (node, "function `%s' definition is marked dllimport.");
+          *no_add_attrs = true;
+        }
+
+      else if (TREE_CODE (node) == VAR_DECL)
+        {
+          if (DECL_INITIAL (node))
+            {
+              error_with_decl (node,"variable `%s' definition is marked dllimport.");
+              *no_add_attrs = true;
+            }
+
+          /* `extern' needn't be specified with dllimport.
+             Specify `extern' now and hope for the best.  Sigh.  */
+          DECL_EXTERNAL (node) = 1;
+          /* Also, implicitly give dllimport'd variables declared within
+             a function global scope, unless declared static.  */
+          if (current_function_decl != NULL_TREE && !TREE_STATIC (node))
+            TREE_PUBLIC (node) = 1;
+        }
+    }
+
+  /*  Report error if symbol is not accessible at global scope. */
+  if (!TREE_PUBLIC (node)
+      && (TREE_CODE (node) == VAR_DECL
+          || TREE_CODE (node) == FUNCTION_DECL))
+    {
+      error_with_decl (node, "external linkage required for symbol '%s' because of '%s' attribute.",
+                       IDENTIFIER_POINTER (name));
+      *no_add_attrs = true;
+    }
+
+  return NULL_TREE;
+}
+
+/* Handle a "shared" attribute;
+   arguments as in struct attribute_spec.handler.  */
+tree
+ix86_handle_shared_attribute (node, name, args, flags, no_add_attrs)
+     tree *node;
+     tree name;
+     tree args ATTRIBUTE_UNUSED;
+     int flags ATTRIBUTE_UNUSED;
+     bool *no_add_attrs;
+{
+  if (TREE_CODE (*node) != VAR_DECL)
+    {
+      warning ("`%s' attribute only applies to variables",
+               IDENTIFIER_POINTER (name));
+      *no_add_attrs = true;
+    }
+
+  return NULL_TREE;
+}
+
+
+/* Return the type that we should use to determine if DECL is
+   imported or exported.  */
+
+static tree
+associated_type (decl)
+     tree decl;
+{
+  tree t = NULL_TREE;
+
+  /* In the C++ frontend, DECL_CONTEXT for a method doesn't actually refer
+     to the containing class.  So we look at the 'this' arg.  */
+  if (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
+    {
+      /* Artificial methods are not affected by the import/export status of
+         their class unless they are virtual.  */
+      if (! DECL_ARTIFICIAL (decl) || DECL_VINDEX (decl))
+        t = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl))));
+    }
+  else if (DECL_CONTEXT (decl)
+           && TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (decl))) == 't')
+    t = DECL_CONTEXT (decl);
+
+  return t;
+}
+
+/* Return nonzero if DECL is a dllexport'd object.  */
+
+static int
+i386_emx_dllexport_p (decl)
+     tree decl;
+{
+  tree exp;
+
+  if (TREE_CODE (decl) != VAR_DECL
+      && TREE_CODE (decl) != FUNCTION_DECL)
+    return 0;
+  exp = lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl));
+  if (exp)
+    return 1;
+
+  /* Class members get the dllexport status of their class.  */
+  if (associated_type (decl))
+    {
+      exp = lookup_attribute ("dllexport",
+                              TYPE_ATTRIBUTES (associated_type (decl)));
+      if (exp)
+        return 1;
+    }
+
+  return 0;
+}
+
+/* Return nonzero if DECL is a dllimport'd object.  */
+
+static int
+i386_emx_dllimport_p (decl)
+     tree decl;
+{
+  tree imp;
+  int context_imp = 0;
+
+  if (TREE_CODE (decl) == FUNCTION_DECL
+      && TARGET_NOP_FUN_DLLIMPORT)
+    return 0;
+
+  if (TREE_CODE (decl) != VAR_DECL
+      && TREE_CODE (decl) != FUNCTION_DECL)
+    return 0;
+
+  imp = lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl));
+
+  /* Class members get the dllimport status of their class.  */
+  if (!imp && associated_type (decl))
+    {
+      imp = lookup_attribute ("dllimport",
+                              TYPE_ATTRIBUTES (associated_type (decl)));
+      if (imp)
+        context_imp = 1;
+    }
+
+  if (imp)
+    {
+      /* Don't mark defined functions as dllimport.  If the definition
+         itself was marked with dllimport, than ix86_handle_dll_attribute
+         reports an error. This handles the case when the definition
+         overrides an earlier declaration.  */
+      if (TREE_CODE (decl) ==  FUNCTION_DECL && DECL_INITIAL (decl)
+          && !DECL_INLINE (decl))
+        {
+           /* Don't warn about artificial methods.  */
+          if (!DECL_ARTIFICIAL (decl))
+            warning_with_decl (decl,"function '%s' is defined after prior declaration as dllimport: attribute ignored.");
+          return 0;
+        }
+
+      /* We ignore the dllimport attribute for inline member functions.
+         This differs from MSVC behaviour which treats it like GNUC
+         'extern inline' extension.   */
+      else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_INLINE (decl))
+        {
+          if (extra_warnings)
+            warning_with_decl (decl, "inline function '%s' is declared as dllimport: attribute ignored.");
+          return 0;
+        }
+
+      /*  Don't allow definitions of static data members in dllimport class,
+          Just ignore attribute for vtable data.  */
+      else if (TREE_CODE (decl) == VAR_DECL
+               && TREE_STATIC (decl) && TREE_PUBLIC (decl)
+               && !DECL_EXTERNAL (decl) && context_imp)
+        {
+          if (!DECL_VIRTUAL_P (decl))
+              error_with_decl (decl, "definition of static data member '%s' of dllimport'd class.");
+           return 0;
+        }
+
+      /* Since we can't treat a pointer to a dllimport'd symbol as a
+         constant address, we turn off the attribute on C++ virtual
+         methods to allow creation of vtables using thunks. */
+      else if (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE
+               && (DECL_VIRTUAL_P (decl)))
+           return 0;
+
+      return 1;
+    }
+
+  return 0;
+}
+
+/* Return nonzero if SYMBOL is marked as being dllexport'd.  */
+
+int
+i386_emx_dllexport_name_p (symbol)
+     const char *symbol;
+{
+  return symbol[0] == DLL_IMPORT_EXPORT_PREFIX
+         && symbol[1] == 'e' && symbol[2] == '.';
+}
+
+/* Return nonzero if SYMBOL is marked as being dllimport'd.  */
+
+int
+i386_emx_dllimport_name_p (symbol)
+     const char *symbol;
+{
+  return symbol[0] == DLL_IMPORT_EXPORT_PREFIX
+         && symbol[1] == 'i' && symbol[2] == '.';
+}
+
+/* Mark a DECL as being dllexport'd.
+   Note that we override the previous setting (eg: dllimport).  */
+
+static void
+i386_emx_mark_dllexport (decl)
+     tree decl;
+{
+  const char *oldname;
+  char  *newname;
+  rtx rtlname;
+  tree idp;
+
+  rtlname = XEXP (DECL_RTL (decl), 0);
+  if (GET_CODE (rtlname) == SYMBOL_REF)
+    oldname = XSTR (rtlname, 0);
+  else if (GET_CODE (rtlname) == MEM
+           && GET_CODE (XEXP (rtlname, 0)) == SYMBOL_REF)
+    oldname = XSTR (XEXP (rtlname, 0), 0);
+  else
+    abort ();
+  if (i386_emx_dllimport_name_p (oldname))
+    {
+      warning_with_decl (decl,"inconsistent dll linkage for '%s': dllexport assumed.");
+     /* Remove DLL_IMPORT_PREFIX.  */
+      oldname += 9;
+      DECL_NON_ADDR_CONST_P (decl) = 0;
+    }
+  else if (i386_emx_dllexport_name_p (oldname))
+    return; /* already done */
+
+  newname = alloca (strlen (oldname) + 4);
+  sprintf (newname, "%ce.%s", DLL_IMPORT_EXPORT_PREFIX, oldname);
+
+  /* We pass newname through get_identifier to ensure it has a unique
+     address.  RTL processing can sometimes peek inside the symbol ref
+     and compare the string's addresses to see if two symbols are
+     identical.  */
+  idp = get_identifier (newname);
+
+  XEXP (DECL_RTL (decl), 0) =
+    gen_rtx (SYMBOL_REF, Pmode, IDENTIFIER_POINTER (idp));
+}
+
+/* Mark a DECL as being dllimport'd.  */
+
+static void
+i386_emx_mark_dllimport (decl)
+     tree decl;
+{
+  const char *oldname;
+  char  *newname;
+  tree idp;
+  rtx rtlname, newrtl;
+
+  rtlname = XEXP (DECL_RTL (decl), 0);
+  if (GET_CODE (rtlname) == SYMBOL_REF)
+    oldname = XSTR (rtlname, 0);
+  else if (GET_CODE (rtlname) == MEM
+           && GET_CODE (XEXP (rtlname, 0)) == SYMBOL_REF)
+    oldname = XSTR (XEXP (rtlname, 0), 0);
+  else
+    abort ();
+  if (i386_emx_dllexport_name_p (oldname))
+    {
+      error ("`%s' declared as both exported to and imported from a DLL",
+             IDENTIFIER_POINTER (DECL_NAME (decl)));
+      return;
+    }
+  else if (i386_emx_dllimport_name_p (oldname))
+    {
+      /* Already done, but do a sanity check to prevent assembler errors. */
+      if (!DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl))
+        {
+          error_with_decl (decl, "failure in redeclaration of '%s': dllimport'd symbol lacks external linkage.");
+          abort();
+        }
+    return;
+    }
+
+  newname = alloca (strlen (oldname) + 11);
+  sprintf (newname, "%ci._imp__%s", DLL_IMPORT_EXPORT_PREFIX, oldname);
+
+  /* We pass newname through get_identifier to ensure it has a unique
+     address.  RTL processing can sometimes peek inside the symbol ref
+     and compare the string's addresses to see if two symbols are
+     identical.  */
+  idp = get_identifier (newname);
+
+  newrtl = gen_rtx (MEM, Pmode,
+                    gen_rtx (SYMBOL_REF, Pmode,
+                             IDENTIFIER_POINTER (idp)));
+  XEXP (DECL_RTL (decl), 0) = newrtl;
+
+  /* Can't treat a pointer to this as a constant address */
+  DECL_NON_ADDR_CONST_P (decl) = 1;
+}
+
+#if 0
+/* Return string which is the former assembler name modified with a
+   suffix consisting of an atsign (@) followed by the number of bytes of
+   arguments */
+
+static const char *
+gen_stdcall_suffix (decl)
+  tree decl;
+{
+  int total = 0;
+  /* ??? This probably should use XSTR (XEXP (DECL_RTL (decl), 0), 0) instead
+     of DECL_ASSEMBLER_NAME.  */
+  const char *asmname = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
+  char *newsym;
+
+  if (TYPE_ARG_TYPES (TREE_TYPE (decl)))
+    if (TREE_VALUE (tree_last (TYPE_ARG_TYPES (TREE_TYPE (decl))))
+        == void_type_node)
+      {
+        tree formal_type = TYPE_ARG_TYPES (TREE_TYPE (decl));
+
+        while (TREE_VALUE (formal_type) != void_type_node)
+          {
+            int parm_size
+              = TREE_INT_CST_LOW (TYPE_SIZE (TREE_VALUE (formal_type)));
+            /* Must round up to include padding.  This is done the same
+               way as in store_one_arg.  */
+            parm_size = ((parm_size + PARM_BOUNDARY - 1)
+                         / PARM_BOUNDARY * PARM_BOUNDARY);
+            total += parm_size;
+            formal_type = TREE_CHAIN (formal_type);
+          }
+      }
+
+  newsym = xmalloc (strlen (asmname) + 10);
+  sprintf (newsym, "%s@%d", asmname, total/BITS_PER_UNIT);
+  return IDENTIFIER_POINTER (get_identifier (newsym));
+}
+#endif
+
+void
+i386_emx_encode_section_info (decl, first)
+     tree decl;
+     int first ATTRIBUTE_UNUSED;
+{
+  /* This bit is copied from i386.h.  */
+  if (optimize > 0 && TREE_CONSTANT (decl)
+      && (!flag_writable_strings || TREE_CODE (decl) != STRING_CST))
+    {
+      rtx rtl = (TREE_CODE_CLASS (TREE_CODE (decl)) != 'd'
+                 ? TREE_CST_RTL (decl) : DECL_RTL (decl));
+      SYMBOL_REF_FLAG (XEXP (rtl, 0)) = 1;
+    }
+
+#if 0
+  if (TREE_CODE (decl) == FUNCTION_DECL)
+    if (lookup_attribute ("stdcall",
+                          TYPE_ATTRIBUTES (TREE_TYPE (decl))))
+      XEXP (DECL_RTL (decl), 0) =
+        gen_rtx (SYMBOL_REF, Pmode, gen_stdcall_suffix (decl));
+#endif
+
+  /* Mark the decl so we can tell from the rtl whether the object is
+     dllexport'd or dllimport'd.  This also handles dllexport/dllimport
+     override semantics.  */
+
+  if (i386_emx_dllexport_p (decl))
+    i386_emx_mark_dllexport (decl);
+  else if (i386_emx_dllimport_p (decl))
+    i386_emx_mark_dllimport (decl);
+  /* It might be that DECL has already been marked as dllimport, but a
+     subsequent definition nullified that.  The attribute is gone but
+     DECL_RTL still has (DLL_IMPORT_EXPORT_PREFIX)i._imp__foo.  We need
+     to remove that. Ditto for the DECL_NON_ADDR_CONST_P flag.  */
+  else if ((TREE_CODE (decl) == FUNCTION_DECL
+            || TREE_CODE (decl) == VAR_DECL)
+           && DECL_RTL (decl) != NULL_RTX
+           && GET_CODE (DECL_RTL (decl)) == MEM
+           && GET_CODE (XEXP (DECL_RTL (decl), 0)) == MEM
+           && GET_CODE (XEXP (XEXP (DECL_RTL (decl), 0), 0)) == SYMBOL_REF
+           && i386_emx_dllimport_name_p (XSTR (XEXP (XEXP (DECL_RTL (decl), 0), 0), 0)))
+    {
+      const char *oldname = XSTR (XEXP (XEXP (DECL_RTL (decl), 0), 0), 0);
+      tree idp = get_identifier (oldname + 9);
+      rtx newrtl = gen_rtx (SYMBOL_REF, Pmode, IDENTIFIER_POINTER (idp));
+
+      warning_with_decl (decl, "'%s' %s after being referenced with dllimport linkage.",
+                         (DECL_INITIAL (decl) || !DECL_EXTERNAL (decl))
+                         ? "defined locally" : "redeclared without dllimport attribute");
+
+      XEXP (DECL_RTL (decl), 0) = newrtl;
+
+      DECL_NON_ADDR_CONST_P (decl) = 0;
+
+      /* We previously set TREE_PUBLIC and DECL_EXTERNAL.
+         We leave these alone for now.  */
+    }
+}
+
+/* [snip] */
+
+#if 0 /* don't think we need this. */
+/* Keep a list of external functions.  */
+
+struct extern_list
+{
+  struct extern_list *next;
+  const char *name;
+};
+
+static struct extern_list *extern_head;
+
+/* Assemble an external function reference.  We need to keep a list of
+   these, so that we can output the function types at the end of the
+   assembly.  We can't output the types now, because we might see a
+   definition of the function later on and emit debugging information
+   for it then.  */
+
+void
+i386_emx_record_external_function (name)
+     const char *name;
+{
+  struct extern_list *p;
+
+  p = (struct extern_list *) xmalloc (sizeof *p);
+  p->next = extern_head;
+  p->name = name;
+  extern_head = p;
+}
+#endif
+
+/* Keep a list of exported symbols.  */
+
+struct export_list
+{
+  struct export_list *next;
+  tree decl;
+  const char *name;
+  const char *asm_name;
+  const char *exported_name;
+  unsigned    ordinal;
+  int is_data;          /* used to type tag exported symbols.  */
+};
+
+static struct export_list *export_head;
+
+/* Assemble an export symbol entry.  We need to keep a list of
+   these, so that we can output the export list at the end of the
+   assembly.  We used to output these export symbols in each function,
+   but that causes problems with GNU ld when the sections are
+   linkonce.  */
+
+void
+i386_emx_record_exported_symbol (decl, name, is_data)
+    tree decl;
+     const char *name;
+     int is_data;
+{
+  struct export_list *p;
+  DUMP(decl);
+
+  p = (struct export_list *) xmalloc (sizeof *p);
+  p->next = export_head;
+  p->decl = decl;
+  p->name = name;
+  p->asm_name = NULL;
+  p->exported_name = NULL;
+  p->ordinal = 0;
+  p->is_data = is_data;
+  export_head = p;
+}
+
+/* This is called at the end of assembly.  For each external function
+   which has not been defined, we output a declaration now.  We also
+   output the .drectve section.  */
+
+void
+i386_emx_asm_file_end (file)
+     FILE *file;
+{
+/*  struct extern_list *p; */
+
+  ix86_asm_file_end (file);
+
+#if 0 /* don't think we need this */
+  for (p = extern_head; p != NULL; p = p->next)
+    {
+      tree decl;
+
+      decl = get_identifier (p->name);
+
+      /* Positively ensure only one declaration for any given symbol.  */
+      if (! TREE_ASM_WRITTEN (decl) && TREE_SYMBOL_REFERENCED (decl))
+        {
+          TREE_ASM_WRITTEN (decl) = 1;
+          i386_emx_declare_function_type (file, p->name, TREE_PUBLIC (decl));
+        }
+    }
+#endif
+  if (export_head)
+    {
+      struct export_list *q;
+      fprintf (file, "\t%s Exports: \"<exportname>,<ordinal>=<asmname>,<code|data>\", N_EXP,0,0,-42\n", ASM_COMMENT_START);
+      for (q = export_head; q != NULL; q = q->next)
+        {
+          static const char * const types[2] = {",code", ",data"};
+          tree decl = q->decl;
+          if (decl)
+            {
+              DUMP(decl);
+              if (!TREE_STATIC (decl))
+                continue;
+              if (!q->asm_name)
+                q->asm_name = q->exported_name ? q->exported_name
+                  : IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
+            }
+          if (!q->asm_name)
+            q->asm_name = q->exported_name ? q->exported_name : q->name;
+          if (!q->exported_name && !q->ordinal)
+            q->exported_name = q->asm_name ? q->asm_name : q->name;
+          fprintf (file, "\t.stabs\t\"");
+          ASM_OUTPUT_LABELREF(file, q->exported_name);
+          fprintf (file, ",%u=", q->ordinal);
+          ASM_OUTPUT_LABELREF(file, q->asm_name);
+          fprintf (file, "%s\",0x6c,0,0,-42\t%s %s\n", /* 0x6c == N_EXP */
+                   types[q->is_data], ASM_COMMENT_START, q->name);
+        }
+    }
+}
+
+

trunk/src/gcc/gcc/config/i386/emx.h ¶

@@ -107 +107 @@
    __register_frame_tableb. */
 #define TARGET_ASM_EH_FRAME_SECTION     emx_eh_frame_section
-extern void emx_eh_frame_section (void);
 
 /* Put exception tables into .data section */
@@ -123 +122 @@
 #define WCHAR_TYPE_SIZE                 16
 
-/* This function handles both _System and _Optlink attributes */
-extern tree emx_handle_vacpp_attribute PARAMS ((tree *, tree, tree, int, _Bool *));
-
 /* We want the _System attribute */
 #define TARGET_SYSTEM_DECL_ATTRIBUTES
@@ -135 +131 @@
 
 /* Do our own mangling on some kinds of decls */
-extern int emx_c_set_decl_assembler_name PARAMS ((tree, int));
 #define TARGET_C_SET_DECL_ASSEMBLER_NAME(decl) \
   emx_c_set_decl_assembler_name (decl, 0)
@@ -143 +138 @@
 /* #631: Hack (temporary, will be fixed properly 3.4.x it seems) for _Optlink and
    _System functions which returns structures. (breaks some tcpip stuff.) */
-extern int emx_return_in_memory_with_fntype PARAMS ((tree type, tree fntype));
 #define RETURN_IN_MEMORY_WITH_FNTYPE    emx_return_in_memory_with_fntype
 
@@ -191 +185 @@
     if ((LOG)!=0) fprintf ((FILE), "\t.align %d,0xcc\n", LOG)
 
-/* Output a reference to a label.  */
+/* Output a reference to a label.
+   We're doing all here since we must get the '*' vs. user_label_prefix
+   bit right. */
 #undef ASM_OUTPUT_LABELREF
-#define ASM_OUTPUT_LABELREF(STREAM, NAME) \
-  fprintf (STREAM, "%s%s", USER_LABEL_PREFIX, NAME)
-
-/* Write a function name in assembly (bad i386.c forces this here). */
-#define ASM_DECLARE_FUNCTION_NAME(FILE, NAME, DECL)  \
-      ASM_OUTPUT_LABEL (FILE, NAME);
+#define ASM_OUTPUT_LABELREF(FILE,NAME) \
+  do { \
+    const char *xname = (NAME); \
+    if (*xname == DLL_IMPORT_EXPORT_PREFIX) \
+      xname += 3; \
+    if (*xname == '%') \
+      xname += 2; \
+    if (*xname == '*') \
+      xname += 1; \
+    else \
+      fputs (user_label_prefix, FILE); \
+    fputs (xname, FILE); \
+  } while (0)
+
+/* Get tree.c to declare a target-specific specialization of
+   merge_decl_attributes.  */
+#define TARGET_DLLIMPORT_DECL_ATTRIBUTES
+
+#undef TARGET_ENCODE_SECTION_INFO
+#define TARGET_ENCODE_SECTION_INFO  i386_emx_encode_section_info
+
+/* Output a common block.  */
+#undef ASM_OUTPUT_ALIGNED_DECL_COMMON
+#define ASM_OUTPUT_ALIGNED_DECL_COMMON(STREAM, DECL, NAME, SIZE, ALIGN) \
+do {                                                    \
+  if (i386_emx_dllexport_name_p (NAME))                 \
+    i386_emx_record_exported_symbol (DECL, NAME, 1);    \
+  if (! i386_emx_dllimport_name_p (NAME))               \
+    {                                                   \
+      /* 16 is the best we can do (segment para). */    \
+      const int xalign = (ALIGN) > 16 ? 16 : (ALIGN);   \
+      fprintf ((STREAM), "\t.comm\t");                  \
+      assemble_name ((STREAM), (NAME));                 \
+      fprintf ((STREAM), ", %d\t%s %d\n",               \
+               (((SIZE) + xalign - 1) / xalign) * xalign, \
+               ASM_COMMENT_START, (SIZE));              \
+    }                                                   \
+} while (0)
+
+/* Output the label for an initialized variable.  */
+#undef ASM_DECLARE_OBJECT_NAME
+#define ASM_DECLARE_OBJECT_NAME(STREAM, NAME, DECL)     \
+do {                                                    \
+  if (i386_emx_dllexport_name_p (NAME))                 \
+    i386_emx_record_exported_symbol (DECL, NAME, 1);    \
+  ASM_OUTPUT_LABEL ((STREAM), (NAME));                  \
+} while (0)
+
+/* Track exported functions... */
+#undef ASM_DECLARE_FUNCTION_NAME
+#define ASM_DECLARE_FUNCTION_NAME(FILE, NAME, DECL)                     \
+  do                                                                    \
+    {                                                                   \
+      if (i386_emx_dllexport_name_p (NAME))                             \
+        i386_emx_record_exported_symbol (DECL, NAME, 0);                \
+      ASM_OUTPUT_LABEL (FILE, NAME);                                    \
+    }                                                                   \
+  while (0)
+
+/* Output function declarations at the end of the file.  */
+#undef ASM_FILE_END
+#define ASM_FILE_END(FILE) \
+  i386_emx_asm_file_end (FILE)
 
 /* Use `#' instead of `/' as assembler comments */
@@ -214 +267 @@
 #undef  TARGET_STRIP_NAME_ENCODING
 #define TARGET_STRIP_NAME_ENCODING      emx_strip_name_encoding_full
-extern const char * emx_strip_name_encoding_full (const char *);
+
+
+/* External function declarations.  */
+
+extern int emx_c_set_decl_assembler_name PARAMS ((tree, int));
+extern int emx_return_in_memory_with_fntype PARAMS ((tree type, tree fntype));
+const char *i386_emx_strip_name_encoding PARAMS ((const char *str));
+extern const char * emx_strip_name_encoding_full PARAMS ((const char *));
+extern void emx_eh_frame_section (void);
+extern void emx_output_function_begin_epilogue (FILE *);
+
+/* This function handles both _System and _Optlink attributes. */
+extern tree emx_handle_vacpp_attribute PARAMS ((tree *, tree, tree, int, _Bool *));
+
+/* These functions are for handling dllexport and dllimport. */
+extern void i386_emx_record_exported_symbol PARAMS ((tree, const char *, int));
+extern void i386_emx_asm_file_end PARAMS ((FILE *));
+extern int i386_emx_dllexport_name_p PARAMS ((const char *));
+extern int i386_emx_dllimport_name_p PARAMS ((const char *));
+extern void i386_emx_encode_section_info PARAMS ((tree, int));
+
 
 
@@ -224 +297 @@
    Also define the -m(no-)epilogue switch. */
 #define MASK_EPILOGUE                   0x40000000  /* Use FUNCTION_EPILOGUE */
+
+/* Masks for subtarget switches used by other files.  */
+#define MASK_NOP_FUN_DLLIMPORT          0x08000000  /* Ignore dllimport for functions */
 
 #undef SUBTARGET_SWITCHES
@@ -230 +306 @@
   { "no-probe",    -MASK_STACK_PROBE, N_("Don't do stack probing") }, \
   { "epilogue",     MASK_EPILOGUE,    N_("Generate prologue/epilogue labels") }, \
-  { "no-epilogue", -MASK_EPILOGUE,    N_("Don't generate prologue/epilogue labels") },
+  { "no-epilogue", -MASK_EPILOGUE,    N_("Don't generate prologue/epilogue labels") }, \
+  { "nop-fun-dllimport", MASK_NOP_FUN_DLLIMPORT, N_("Ignore dllimport for functions") }, \
+  { "no-nop-fun-dllimport", -MASK_NOP_FUN_DLLIMPORT, "" },
 
 /* Use FUNCTION_EPILOGUE */
 #define TARGET_EPILOGUE                 (target_flags & MASK_EPILOGUE)
 
+/* Used in winnt.c.  */
+#define TARGET_NOP_FUN_DLLIMPORT        (target_flags & MASK_NOP_FUN_DLLIMPORT)
 
 /* By default, target has a 80387, uses IEEE compatible arithmetic,
@@ -247 +327 @@
                                     || !strcmp (STR, "Zstack"))
 
+/* Don't allow flag_pic to propagate since gas may produce invalid code
+   otherwise.  */
+#undef  SUBTARGET_OVERRIDE_OPTIONS
+#define SUBTARGET_OVERRIDE_OPTIONS                                      \
+do {                                                                    \
+  if (flag_pic)                                                         \
+    {                                                                   \
+      warning ("-f%s ignored for target (all code is position independent)",\
+               (flag_pic > 1) ? "PIC" : "pic");                         \
+      flag_pic = 0;                                                     \
+    }                                                                   \
+} while (0)
+
 /* Add a __POST$xxx label before epilogue if -mepilogue specified */
-extern void emx_output_function_begin_epilogue (FILE *);
 #undef TARGET_ASM_FUNCTION_BEGIN_EPILOGUE
 #define TARGET_ASM_FUNCTION_BEGIN_EPILOGUE emx_output_function_begin_epilogue
@@ -287 +379 @@
         builtin_define ("_Optlink=__attribute__((__optlink__))");       \
         builtin_define ("_System=__attribute__((__system__))");         \
+        builtin_define ("_Export=__attribute__((dllexport))");          \
+        builtin_define ("__declspec(x)=__attribute__((x))");            \
         if (!flag_iso)                                                  \
           {                                                             \