/* Subroutines for insn-output.c for Windows NT.
|
/* Subroutines for insn-output.c for Windows NT.
|
Contributed by Douglas Rupp (drupp@cs.washington.edu)
|
Contributed by Douglas Rupp (drupp@cs.washington.edu)
|
Copyright (C) 1995, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
|
Copyright (C) 1995, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
|
2005, 2006, 2007 Free Software Foundation, Inc.
|
2005, 2006, 2007 Free Software Foundation, Inc.
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
GCC is free software; you can redistribute it and/or modify it under
|
the terms of the GNU General Public License as published by the Free
|
the terms of the GNU General Public License as published by the Free
|
Software Foundation; either version 3, or (at your option) any later
|
Software Foundation; either version 3, or (at your option) any later
|
version.
|
version.
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
for more details.
|
for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "rtl.h"
|
#include "rtl.h"
|
#include "regs.h"
|
#include "regs.h"
|
#include "hard-reg-set.h"
|
#include "hard-reg-set.h"
|
#include "output.h"
|
#include "output.h"
|
#include "tree.h"
|
#include "tree.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "tm_p.h"
|
#include "tm_p.h"
|
#include "toplev.h"
|
#include "toplev.h"
|
#include "hashtab.h"
|
#include "hashtab.h"
|
#include "ggc.h"
|
#include "ggc.h"
|
|
|
/* i386/PE specific attribute support.
|
/* i386/PE specific attribute support.
|
|
|
i386/PE has two new attributes:
|
i386/PE has two new attributes:
|
dllexport - for exporting a function/variable that will live in a dll
|
dllexport - for exporting a function/variable that will live in a dll
|
dllimport - for importing a function/variable from a dll
|
dllimport - for importing a function/variable from a dll
|
|
|
Microsoft allows multiple declspecs in one __declspec, separating
|
Microsoft allows multiple declspecs in one __declspec, separating
|
them with spaces. We do NOT support this. Instead, use __declspec
|
them with spaces. We do NOT support this. Instead, use __declspec
|
multiple times.
|
multiple times.
|
*/
|
*/
|
|
|
static tree associated_type (tree);
|
static tree associated_type (tree);
|
static tree gen_stdcall_or_fastcall_suffix (tree, bool);
|
static tree gen_stdcall_or_fastcall_suffix (tree, bool);
|
static bool i386_pe_dllexport_p (tree);
|
static bool i386_pe_dllexport_p (tree);
|
static bool i386_pe_dllimport_p (tree);
|
static bool i386_pe_dllimport_p (tree);
|
static void i386_pe_mark_dllexport (tree);
|
static void i386_pe_mark_dllexport (tree);
|
static void i386_pe_mark_dllimport (tree);
|
static void i386_pe_mark_dllimport (tree);
|
|
|
/* This is we how mark internal identifiers with dllimport or dllexport
|
/* This is we how mark internal identifiers with dllimport or dllexport
|
attributes. */
|
attributes. */
|
#ifndef DLL_IMPORT_PREFIX
|
#ifndef DLL_IMPORT_PREFIX
|
#define DLL_IMPORT_PREFIX "#i."
|
#define DLL_IMPORT_PREFIX "#i."
|
#endif
|
#endif
|
#ifndef DLL_EXPORT_PREFIX
|
#ifndef DLL_EXPORT_PREFIX
|
#define DLL_EXPORT_PREFIX "#e."
|
#define DLL_EXPORT_PREFIX "#e."
|
#endif
|
#endif
|
|
|
/* Handle a "shared" attribute;
|
/* Handle a "shared" attribute;
|
arguments as in struct attribute_spec.handler. */
|
arguments as in struct attribute_spec.handler. */
|
tree
|
tree
|
ix86_handle_shared_attribute (tree *node, tree name,
|
ix86_handle_shared_attribute (tree *node, tree name,
|
tree args ATTRIBUTE_UNUSED,
|
tree args ATTRIBUTE_UNUSED,
|
int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
|
int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
|
{
|
{
|
if (TREE_CODE (*node) != VAR_DECL)
|
if (TREE_CODE (*node) != VAR_DECL)
|
{
|
{
|
warning (OPT_Wattributes, "%qs attribute only applies to variables",
|
warning (OPT_Wattributes, "%qs attribute only applies to variables",
|
IDENTIFIER_POINTER (name));
|
IDENTIFIER_POINTER (name));
|
*no_add_attrs = true;
|
*no_add_attrs = true;
|
}
|
}
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* Handle a "selectany" attribute;
|
/* Handle a "selectany" attribute;
|
arguments as in struct attribute_spec.handler. */
|
arguments as in struct attribute_spec.handler. */
|
tree
|
tree
|
ix86_handle_selectany_attribute (tree *node, tree name,
|
ix86_handle_selectany_attribute (tree *node, tree name,
|
tree args ATTRIBUTE_UNUSED,
|
tree args ATTRIBUTE_UNUSED,
|
int flags ATTRIBUTE_UNUSED,
|
int flags ATTRIBUTE_UNUSED,
|
bool *no_add_attrs)
|
bool *no_add_attrs)
|
{
|
{
|
/* The attribute applies only to objects that are initialized and have
|
/* The attribute applies only to objects that are initialized and have
|
external linkage. However, we may not know about initialization
|
external linkage. However, we may not know about initialization
|
until the language frontend has processed the decl. We'll check for
|
until the language frontend has processed the decl. We'll check for
|
initialization later in encode_section_info. */
|
initialization later in encode_section_info. */
|
if (TREE_CODE (*node) != VAR_DECL || !TREE_PUBLIC (*node))
|
if (TREE_CODE (*node) != VAR_DECL || !TREE_PUBLIC (*node))
|
{
|
{
|
error ("%qs attribute applies only to initialized variables"
|
error ("%qs attribute applies only to initialized variables"
|
" with external linkage", IDENTIFIER_POINTER (name));
|
" with external linkage", IDENTIFIER_POINTER (name));
|
*no_add_attrs = true;
|
*no_add_attrs = true;
|
}
|
}
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
|
|
/* Return the type that we should use to determine if DECL is
|
/* Return the type that we should use to determine if DECL is
|
imported or exported. */
|
imported or exported. */
|
|
|
static tree
|
static tree
|
associated_type (tree decl)
|
associated_type (tree decl)
|
{
|
{
|
return (DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl)))
|
return (DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl)))
|
? DECL_CONTEXT (decl) : NULL_TREE;
|
? DECL_CONTEXT (decl) : NULL_TREE;
|
}
|
}
|
|
|
|
|
/* Return true if DECL is a dllexport'd object. */
|
/* Return true if DECL is a dllexport'd object. */
|
|
|
static bool
|
static bool
|
i386_pe_dllexport_p (tree decl)
|
i386_pe_dllexport_p (tree decl)
|
{
|
{
|
if (TREE_CODE (decl) != VAR_DECL
|
if (TREE_CODE (decl) != VAR_DECL
|
&& TREE_CODE (decl) != FUNCTION_DECL)
|
&& TREE_CODE (decl) != FUNCTION_DECL)
|
return false;
|
return false;
|
|
|
if (lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))
|
if (lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))
|
return true;
|
return true;
|
|
|
/* Also mark class members of exported classes with dllexport. */
|
/* Also mark class members of exported classes with dllexport. */
|
if (associated_type (decl)
|
if (associated_type (decl)
|
&& lookup_attribute ("dllexport",
|
&& lookup_attribute ("dllexport",
|
TYPE_ATTRIBUTES (associated_type (decl))))
|
TYPE_ATTRIBUTES (associated_type (decl))))
|
return i386_pe_type_dllexport_p (decl);
|
return i386_pe_type_dllexport_p (decl);
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
static bool
|
static bool
|
i386_pe_dllimport_p (tree decl)
|
i386_pe_dllimport_p (tree decl)
|
{
|
{
|
if (TREE_CODE (decl) != VAR_DECL
|
if (TREE_CODE (decl) != VAR_DECL
|
&& TREE_CODE (decl) != FUNCTION_DECL)
|
&& TREE_CODE (decl) != FUNCTION_DECL)
|
return false;
|
return false;
|
|
|
/* Lookup the attribute in addition to checking the DECL_DLLIMPORT_P flag.
|
/* Lookup the attribute in addition to checking the DECL_DLLIMPORT_P flag.
|
We may need to override an earlier decision. */
|
We may need to override an earlier decision. */
|
if (DECL_DLLIMPORT_P (decl)
|
if (DECL_DLLIMPORT_P (decl)
|
&& lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl)))
|
&& lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl)))
|
{
|
{
|
/* Make a final check to see if this is a definition before we generate
|
/* Make a final check to see if this is a definition before we generate
|
RTL for an indirect reference. */
|
RTL for an indirect reference. */
|
if (!DECL_EXTERNAL (decl))
|
if (!DECL_EXTERNAL (decl))
|
{
|
{
|
error ("%q+D: definition is marked as dllimport", decl);
|
error ("%q+D: definition is marked as dllimport", decl);
|
DECL_DLLIMPORT_P (decl) = 0;
|
DECL_DLLIMPORT_P (decl) = 0;
|
return false;
|
return false;
|
}
|
}
|
return true;
|
return true;
|
}
|
}
|
/* The DECL_DLLIMPORT_P flag was set for decls in the class definition
|
/* The DECL_DLLIMPORT_P flag was set for decls in the class definition
|
by targetm.cxx.adjust_class_at_definition. Check again to emit
|
by targetm.cxx.adjust_class_at_definition. Check again to emit
|
warnings if the class attribute has been overridden by an
|
warnings if the class attribute has been overridden by an
|
out-of-class definition. */
|
out-of-class definition. */
|
else if (associated_type (decl)
|
else if (associated_type (decl)
|
&& lookup_attribute ("dllimport",
|
&& lookup_attribute ("dllimport",
|
TYPE_ATTRIBUTES (associated_type (decl))))
|
TYPE_ATTRIBUTES (associated_type (decl))))
|
return i386_pe_type_dllimport_p (decl);
|
return i386_pe_type_dllimport_p (decl);
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Handle the -mno-fun-dllimport target switch. */
|
/* Handle the -mno-fun-dllimport target switch. */
|
bool
|
bool
|
i386_pe_valid_dllimport_attribute_p (tree decl)
|
i386_pe_valid_dllimport_attribute_p (tree decl)
|
{
|
{
|
if (TARGET_NOP_FUN_DLLIMPORT && TREE_CODE (decl) == FUNCTION_DECL)
|
if (TARGET_NOP_FUN_DLLIMPORT && TREE_CODE (decl) == FUNCTION_DECL)
|
return false;
|
return false;
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Return nonzero if SYMBOL is marked as being dllexport'd. */
|
/* Return nonzero if SYMBOL is marked as being dllexport'd. */
|
|
|
int
|
int
|
i386_pe_dllexport_name_p (const char *symbol)
|
i386_pe_dllexport_name_p (const char *symbol)
|
{
|
{
|
return (strncmp (DLL_EXPORT_PREFIX, symbol,
|
return (strncmp (DLL_EXPORT_PREFIX, symbol,
|
strlen (DLL_EXPORT_PREFIX)) == 0);
|
strlen (DLL_EXPORT_PREFIX)) == 0);
|
}
|
}
|
|
|
/* Return nonzero if SYMBOL is marked as being dllimport'd. */
|
/* Return nonzero if SYMBOL is marked as being dllimport'd. */
|
|
|
int
|
int
|
i386_pe_dllimport_name_p (const char *symbol)
|
i386_pe_dllimport_name_p (const char *symbol)
|
{
|
{
|
return (strncmp (DLL_IMPORT_PREFIX, symbol,
|
return (strncmp (DLL_IMPORT_PREFIX, symbol,
|
strlen (DLL_IMPORT_PREFIX)) == 0);
|
strlen (DLL_IMPORT_PREFIX)) == 0);
|
}
|
}
|
|
|
/* Mark a DECL as being dllexport'd.
|
/* Mark a DECL as being dllexport'd.
|
Note that we override the previous setting (e.g.: dllimport). */
|
Note that we override the previous setting (e.g.: dllimport). */
|
|
|
static void
|
static void
|
i386_pe_mark_dllexport (tree decl)
|
i386_pe_mark_dllexport (tree decl)
|
{
|
{
|
const char *oldname;
|
const char *oldname;
|
char *newname;
|
char *newname;
|
rtx rtlname;
|
rtx rtlname;
|
rtx symref;
|
rtx symref;
|
tree idp;
|
tree idp;
|
|
|
rtlname = XEXP (DECL_RTL (decl), 0);
|
rtlname = XEXP (DECL_RTL (decl), 0);
|
if (GET_CODE (rtlname) == MEM)
|
if (GET_CODE (rtlname) == MEM)
|
rtlname = XEXP (rtlname, 0);
|
rtlname = XEXP (rtlname, 0);
|
gcc_assert (GET_CODE (rtlname) == SYMBOL_REF);
|
gcc_assert (GET_CODE (rtlname) == SYMBOL_REF);
|
oldname = XSTR (rtlname, 0);
|
oldname = XSTR (rtlname, 0);
|
if (i386_pe_dllimport_name_p (oldname))
|
if (i386_pe_dllimport_name_p (oldname))
|
{
|
{
|
warning (0, "inconsistent dll linkage for %q+D, dllexport assumed",
|
warning (0, "inconsistent dll linkage for %q+D, dllexport assumed",
|
decl);
|
decl);
|
/* Remove DLL_IMPORT_PREFIX. */
|
/* Remove DLL_IMPORT_PREFIX. */
|
oldname += strlen (DLL_IMPORT_PREFIX);
|
oldname += strlen (DLL_IMPORT_PREFIX);
|
}
|
}
|
else if (i386_pe_dllexport_name_p (oldname))
|
else if (i386_pe_dllexport_name_p (oldname))
|
return; /* already done */
|
return; /* already done */
|
|
|
newname = alloca (strlen (DLL_EXPORT_PREFIX) + strlen (oldname) + 1);
|
newname = alloca (strlen (DLL_EXPORT_PREFIX) + strlen (oldname) + 1);
|
sprintf (newname, "%s%s", DLL_EXPORT_PREFIX, oldname);
|
sprintf (newname, "%s%s", DLL_EXPORT_PREFIX, oldname);
|
|
|
/* We pass newname through get_identifier to ensure it has a unique
|
/* We pass newname through get_identifier to ensure it has a unique
|
address. RTL processing can sometimes peek inside the symbol ref
|
address. RTL processing can sometimes peek inside the symbol ref
|
and compare the string's addresses to see if two symbols are
|
and compare the string's addresses to see if two symbols are
|
identical. */
|
identical. */
|
idp = get_identifier (newname);
|
idp = get_identifier (newname);
|
|
|
symref = gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (idp));
|
symref = gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (idp));
|
SET_SYMBOL_REF_DECL (symref, decl);
|
SET_SYMBOL_REF_DECL (symref, decl);
|
XEXP (DECL_RTL (decl), 0) = symref;
|
XEXP (DECL_RTL (decl), 0) = symref;
|
}
|
}
|
|
|
/* Mark a DECL as being dllimport'd. */
|
/* Mark a DECL as being dllimport'd. */
|
|
|
static void
|
static void
|
i386_pe_mark_dllimport (tree decl)
|
i386_pe_mark_dllimport (tree decl)
|
{
|
{
|
const char *oldname;
|
const char *oldname;
|
char *newname;
|
char *newname;
|
tree idp;
|
tree idp;
|
rtx rtlname, newrtl;
|
rtx rtlname, newrtl;
|
rtx symref;
|
rtx symref;
|
|
|
rtlname = XEXP (DECL_RTL (decl), 0);
|
rtlname = XEXP (DECL_RTL (decl), 0);
|
if (GET_CODE (rtlname) == MEM)
|
if (GET_CODE (rtlname) == MEM)
|
rtlname = XEXP (rtlname, 0);
|
rtlname = XEXP (rtlname, 0);
|
gcc_assert (GET_CODE (rtlname) == SYMBOL_REF);
|
gcc_assert (GET_CODE (rtlname) == SYMBOL_REF);
|
oldname = XSTR (rtlname, 0);
|
oldname = XSTR (rtlname, 0);
|
if (i386_pe_dllexport_name_p (oldname))
|
if (i386_pe_dllexport_name_p (oldname))
|
{
|
{
|
error ("%qs declared as both exported to and imported from a DLL",
|
error ("%qs declared as both exported to and imported from a DLL",
|
IDENTIFIER_POINTER (DECL_NAME (decl)));
|
IDENTIFIER_POINTER (DECL_NAME (decl)));
|
return;
|
return;
|
}
|
}
|
else if (i386_pe_dllimport_name_p (oldname))
|
else if (i386_pe_dllimport_name_p (oldname))
|
{
|
{
|
/* Already done, but do a sanity check to prevent assembler
|
/* Already done, but do a sanity check to prevent assembler
|
errors. */
|
errors. */
|
gcc_assert (DECL_EXTERNAL (decl) && TREE_PUBLIC (decl)
|
gcc_assert (DECL_EXTERNAL (decl) && TREE_PUBLIC (decl)
|
&& DECL_DLLIMPORT_P (decl));
|
&& DECL_DLLIMPORT_P (decl));
|
return;
|
return;
|
}
|
}
|
|
|
newname = alloca (strlen (DLL_IMPORT_PREFIX) + strlen (oldname) + 1);
|
newname = alloca (strlen (DLL_IMPORT_PREFIX) + strlen (oldname) + 1);
|
sprintf (newname, "%s%s", DLL_IMPORT_PREFIX, oldname);
|
sprintf (newname, "%s%s", DLL_IMPORT_PREFIX, oldname);
|
|
|
/* We pass newname through get_identifier to ensure it has a unique
|
/* We pass newname through get_identifier to ensure it has a unique
|
address. RTL processing can sometimes peek inside the symbol ref
|
address. RTL processing can sometimes peek inside the symbol ref
|
and compare the string's addresses to see if two symbols are
|
and compare the string's addresses to see if two symbols are
|
identical. */
|
identical. */
|
idp = get_identifier (newname);
|
idp = get_identifier (newname);
|
|
|
symref = gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (idp));
|
symref = gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (idp));
|
SET_SYMBOL_REF_DECL (symref, decl);
|
SET_SYMBOL_REF_DECL (symref, decl);
|
newrtl = gen_rtx_MEM (Pmode,symref);
|
newrtl = gen_rtx_MEM (Pmode,symref);
|
XEXP (DECL_RTL (decl), 0) = newrtl;
|
XEXP (DECL_RTL (decl), 0) = newrtl;
|
|
|
DECL_DLLIMPORT_P (decl) = 1;
|
DECL_DLLIMPORT_P (decl) = 1;
|
}
|
}
|
|
|
/* Return string which is the former assembler name modified with a
|
/* Return string which is the former assembler name modified with a
|
suffix consisting of an atsign (@) followed by the number of bytes of
|
suffix consisting of an atsign (@) followed by the number of bytes of
|
arguments. If FASTCALL is true, also add the FASTCALL_PREFIX. */
|
arguments. If FASTCALL is true, also add the FASTCALL_PREFIX. */
|
|
|
static tree
|
static tree
|
gen_stdcall_or_fastcall_suffix (tree decl, bool fastcall)
|
gen_stdcall_or_fastcall_suffix (tree decl, bool fastcall)
|
{
|
{
|
int total = 0;
|
int total = 0;
|
/* ??? This probably should use XSTR (XEXP (DECL_RTL (decl), 0), 0) instead
|
/* ??? This probably should use XSTR (XEXP (DECL_RTL (decl), 0), 0) instead
|
of DECL_ASSEMBLER_NAME. */
|
of DECL_ASSEMBLER_NAME. */
|
const char *asmname = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
|
const char *asmname = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
|
char *newsym;
|
char *newsym;
|
char *p;
|
char *p;
|
tree formal_type;
|
tree formal_type;
|
|
|
/* Do not change the identifier if a verbatim asmspec or already done. */
|
/* Do not change the identifier if a verbatim asmspec or already done. */
|
if (*asmname == '*' || strchr (asmname, '@'))
|
if (*asmname == '*' || strchr (asmname, '@'))
|
return DECL_ASSEMBLER_NAME (decl);
|
return DECL_ASSEMBLER_NAME (decl);
|
|
|
formal_type = TYPE_ARG_TYPES (TREE_TYPE (decl));
|
formal_type = TYPE_ARG_TYPES (TREE_TYPE (decl));
|
if (formal_type != NULL_TREE)
|
if (formal_type != NULL_TREE)
|
{
|
{
|
/* These attributes are ignored for variadic functions in
|
/* These attributes are ignored for variadic functions in
|
i386.c:ix86_return_pops_args. For compatibility with MS
|
i386.c:ix86_return_pops_args. For compatibility with MS
|
compiler do not add @0 suffix here. */
|
compiler do not add @0 suffix here. */
|
if (TREE_VALUE (tree_last (formal_type)) != void_type_node)
|
if (TREE_VALUE (tree_last (formal_type)) != void_type_node)
|
return DECL_ASSEMBLER_NAME (decl);
|
return DECL_ASSEMBLER_NAME (decl);
|
|
|
/* Quit if we hit an incomplete type. Error is reported
|
/* Quit if we hit an incomplete type. Error is reported
|
by convert_arguments in c-typeck.c or cp/typeck.c. */
|
by convert_arguments in c-typeck.c or cp/typeck.c. */
|
while (TREE_VALUE (formal_type) != void_type_node
|
while (TREE_VALUE (formal_type) != void_type_node
|
&& COMPLETE_TYPE_P (TREE_VALUE (formal_type)))
|
&& COMPLETE_TYPE_P (TREE_VALUE (formal_type)))
|
{
|
{
|
int parm_size
|
int parm_size
|
= TREE_INT_CST_LOW (TYPE_SIZE (TREE_VALUE (formal_type)));
|
= TREE_INT_CST_LOW (TYPE_SIZE (TREE_VALUE (formal_type)));
|
/* Must round up to include padding. This is done the same
|
/* Must round up to include padding. This is done the same
|
way as in store_one_arg. */
|
way as in store_one_arg. */
|
parm_size = ((parm_size + PARM_BOUNDARY - 1)
|
parm_size = ((parm_size + PARM_BOUNDARY - 1)
|
/ PARM_BOUNDARY * PARM_BOUNDARY);
|
/ PARM_BOUNDARY * PARM_BOUNDARY);
|
total += parm_size;
|
total += parm_size;
|
formal_type = TREE_CHAIN (formal_type);\
|
formal_type = TREE_CHAIN (formal_type);\
|
}
|
}
|
}
|
}
|
|
|
/* Assume max of 8 base 10 digits in the suffix. */
|
/* Assume max of 8 base 10 digits in the suffix. */
|
newsym = alloca (1 + strlen (asmname) + 1 + 8 + 1);
|
newsym = alloca (1 + strlen (asmname) + 1 + 8 + 1);
|
p = newsym;
|
p = newsym;
|
if (fastcall)
|
if (fastcall)
|
*p++ = FASTCALL_PREFIX;
|
*p++ = FASTCALL_PREFIX;
|
sprintf (p, "%s@%d", asmname, total/BITS_PER_UNIT);
|
sprintf (p, "%s@%d", asmname, total/BITS_PER_UNIT);
|
return get_identifier (newsym);
|
return get_identifier (newsym);
|
}
|
}
|
|
|
void
|
void
|
i386_pe_encode_section_info (tree decl, rtx rtl, int first)
|
i386_pe_encode_section_info (tree decl, rtx rtl, int first)
|
{
|
{
|
default_encode_section_info (decl, rtl, first);
|
default_encode_section_info (decl, rtl, first);
|
|
|
if (first && TREE_CODE (decl) == FUNCTION_DECL)
|
if (first && TREE_CODE (decl) == FUNCTION_DECL)
|
{
|
{
|
tree type_attributes = TYPE_ATTRIBUTES (TREE_TYPE (decl));
|
tree type_attributes = TYPE_ATTRIBUTES (TREE_TYPE (decl));
|
tree newid = NULL_TREE;
|
tree newid = NULL_TREE;
|
|
|
if (lookup_attribute ("stdcall", type_attributes))
|
if (lookup_attribute ("stdcall", type_attributes))
|
newid = gen_stdcall_or_fastcall_suffix (decl, false);
|
newid = gen_stdcall_or_fastcall_suffix (decl, false);
|
else if (lookup_attribute ("fastcall", type_attributes))
|
else if (lookup_attribute ("fastcall", type_attributes))
|
newid = gen_stdcall_or_fastcall_suffix (decl, true);
|
newid = gen_stdcall_or_fastcall_suffix (decl, true);
|
if (newid != NULL_TREE)
|
if (newid != NULL_TREE)
|
{
|
{
|
rtx rtlname = XEXP (rtl, 0);
|
rtx rtlname = XEXP (rtl, 0);
|
if (GET_CODE (rtlname) == MEM)
|
if (GET_CODE (rtlname) == MEM)
|
rtlname = XEXP (rtlname, 0);
|
rtlname = XEXP (rtlname, 0);
|
XSTR (rtlname, 0) = IDENTIFIER_POINTER (newid);
|
XSTR (rtlname, 0) = IDENTIFIER_POINTER (newid);
|
/* These attributes must be present on first declaration,
|
/* These attributes must be present on first declaration,
|
change_decl_assembler_name will warn if they are added
|
change_decl_assembler_name will warn if they are added
|
later and the decl has been referenced, but duplicate_decls
|
later and the decl has been referenced, but duplicate_decls
|
should catch the mismatch before this is called. */
|
should catch the mismatch before this is called. */
|
change_decl_assembler_name (decl, newid);
|
change_decl_assembler_name (decl, newid);
|
}
|
}
|
}
|
}
|
|
|
else if (TREE_CODE (decl) == VAR_DECL
|
else if (TREE_CODE (decl) == VAR_DECL
|
&& lookup_attribute ("selectany", DECL_ATTRIBUTES (decl)))
|
&& lookup_attribute ("selectany", DECL_ATTRIBUTES (decl)))
|
{
|
{
|
if (DECL_INITIAL (decl)
|
if (DECL_INITIAL (decl)
|
/* If an object is initialized with a ctor, the static
|
/* If an object is initialized with a ctor, the static
|
initialization and destruction code for it is present in
|
initialization and destruction code for it is present in
|
each unit defining the object. The code that calls the
|
each unit defining the object. The code that calls the
|
ctor is protected by a link-once guard variable, so that
|
ctor is protected by a link-once guard variable, so that
|
the object still has link-once semantics, */
|
the object still has link-once semantics, */
|
|| TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
|
|| TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
|
make_decl_one_only (decl);
|
make_decl_one_only (decl);
|
else
|
else
|
error ("%q+D:'selectany' attribute applies only to initialized objects",
|
error ("%q+D:'selectany' attribute applies only to initialized objects",
|
decl);
|
decl);
|
}
|
}
|
|
|
/* Mark the decl so we can tell from the rtl whether the object is
|
/* Mark the decl so we can tell from the rtl whether the object is
|
dllexport'd or dllimport'd. tree.c: merge_dllimport_decl_attributes
|
dllexport'd or dllimport'd. tree.c: merge_dllimport_decl_attributes
|
handles dllexport/dllimport override semantics. */
|
handles dllexport/dllimport override semantics. */
|
|
|
if (i386_pe_dllexport_p (decl))
|
if (i386_pe_dllexport_p (decl))
|
i386_pe_mark_dllexport (decl);
|
i386_pe_mark_dllexport (decl);
|
else if (i386_pe_dllimport_p (decl))
|
else if (i386_pe_dllimport_p (decl))
|
i386_pe_mark_dllimport (decl);
|
i386_pe_mark_dllimport (decl);
|
/* It might be that DECL has been declared as dllimport, but a
|
/* It might be that DECL has been declared as dllimport, but a
|
subsequent definition nullified that. Assert that
|
subsequent definition nullified that. Assert that
|
tree.c: merge_dllimport_decl_attributes has removed the attribute
|
tree.c: merge_dllimport_decl_attributes has removed the attribute
|
before the RTL name was marked with the DLL_IMPORT_PREFIX. */
|
before the RTL name was marked with the DLL_IMPORT_PREFIX. */
|
else
|
else
|
gcc_assert (!((TREE_CODE (decl) == FUNCTION_DECL
|
gcc_assert (!((TREE_CODE (decl) == FUNCTION_DECL
|
|| TREE_CODE (decl) == VAR_DECL)
|
|| TREE_CODE (decl) == VAR_DECL)
|
&& rtl != NULL_RTX
|
&& rtl != NULL_RTX
|
&& GET_CODE (rtl) == MEM
|
&& GET_CODE (rtl) == MEM
|
&& GET_CODE (XEXP (rtl, 0)) == MEM
|
&& GET_CODE (XEXP (rtl, 0)) == MEM
|
&& GET_CODE (XEXP (XEXP (rtl, 0), 0)) == SYMBOL_REF
|
&& GET_CODE (XEXP (XEXP (rtl, 0), 0)) == SYMBOL_REF
|
&& i386_pe_dllimport_name_p (XSTR (XEXP (XEXP (rtl, 0), 0), 0))));
|
&& i386_pe_dllimport_name_p (XSTR (XEXP (XEXP (rtl, 0), 0), 0))));
|
}
|
}
|
|
|
/* Strip only the leading encoding, leaving the stdcall suffix and fastcall
|
/* Strip only the leading encoding, leaving the stdcall suffix and fastcall
|
prefix if it exists. */
|
prefix if it exists. */
|
|
|
const char *
|
const char *
|
i386_pe_strip_name_encoding (const char *str)
|
i386_pe_strip_name_encoding (const char *str)
|
{
|
{
|
if (strncmp (str, DLL_IMPORT_PREFIX, strlen (DLL_IMPORT_PREFIX))
|
if (strncmp (str, DLL_IMPORT_PREFIX, strlen (DLL_IMPORT_PREFIX))
|
== 0)
|
== 0)
|
str += strlen (DLL_IMPORT_PREFIX);
|
str += strlen (DLL_IMPORT_PREFIX);
|
else if (strncmp (str, DLL_EXPORT_PREFIX, strlen (DLL_EXPORT_PREFIX))
|
else if (strncmp (str, DLL_EXPORT_PREFIX, strlen (DLL_EXPORT_PREFIX))
|
== 0)
|
== 0)
|
str += strlen (DLL_EXPORT_PREFIX);
|
str += strlen (DLL_EXPORT_PREFIX);
|
if (*str == '*')
|
if (*str == '*')
|
str += 1;
|
str += 1;
|
return str;
|
return str;
|
}
|
}
|
|
|
/* Also strip the fastcall prefix and stdcall suffix. */
|
/* Also strip the fastcall prefix and stdcall suffix. */
|
|
|
const char *
|
const char *
|
i386_pe_strip_name_encoding_full (const char *str)
|
i386_pe_strip_name_encoding_full (const char *str)
|
{
|
{
|
const char *p;
|
const char *p;
|
const char *name = i386_pe_strip_name_encoding (str);
|
const char *name = i386_pe_strip_name_encoding (str);
|
|
|
/* Strip leading '@' on fastcall symbols. */
|
/* Strip leading '@' on fastcall symbols. */
|
if (*name == '@')
|
if (*name == '@')
|
name++;
|
name++;
|
|
|
/* Strip trailing "@n". */
|
/* Strip trailing "@n". */
|
p = strchr (name, '@');
|
p = strchr (name, '@');
|
if (p)
|
if (p)
|
return ggc_alloc_string (name, p - name);
|
return ggc_alloc_string (name, p - name);
|
|
|
return name;
|
return name;
|
}
|
}
|
|
|
/* Output a reference to a label. Fastcall symbols are prefixed with @,
|
/* Output a reference to a label. Fastcall symbols are prefixed with @,
|
whereas symbols for functions using other calling conventions don't
|
whereas symbols for functions using other calling conventions don't
|
have a prefix (unless they are marked dllimport or dllexport). */
|
have a prefix (unless they are marked dllimport or dllexport). */
|
|
|
void i386_pe_output_labelref (FILE *stream, const char *name)
|
void i386_pe_output_labelref (FILE *stream, const char *name)
|
{
|
{
|
if (strncmp (name, DLL_IMPORT_PREFIX, strlen (DLL_IMPORT_PREFIX))
|
if (strncmp (name, DLL_IMPORT_PREFIX, strlen (DLL_IMPORT_PREFIX))
|
== 0)
|
== 0)
|
/* A dll import */
|
/* A dll import */
|
{
|
{
|
if (name[strlen (DLL_IMPORT_PREFIX)] == FASTCALL_PREFIX)
|
if (name[strlen (DLL_IMPORT_PREFIX)] == FASTCALL_PREFIX)
|
/* A dllimport fastcall symbol. */
|
/* A dllimport fastcall symbol. */
|
{
|
{
|
fprintf (stream, "__imp_%s",
|
fprintf (stream, "__imp_%s",
|
i386_pe_strip_name_encoding (name));
|
i386_pe_strip_name_encoding (name));
|
}
|
}
|
else
|
else
|
/* A dllimport non-fastcall symbol. */
|
/* A dllimport non-fastcall symbol. */
|
{
|
{
|
fprintf (stream, "__imp__%s",
|
fprintf (stream, "__imp__%s",
|
i386_pe_strip_name_encoding (name));
|
i386_pe_strip_name_encoding (name));
|
}
|
}
|
}
|
}
|
else if ((name[0] == FASTCALL_PREFIX)
|
else if ((name[0] == FASTCALL_PREFIX)
|
|| (strncmp (name, DLL_EXPORT_PREFIX, strlen (DLL_EXPORT_PREFIX))
|
|| (strncmp (name, DLL_EXPORT_PREFIX, strlen (DLL_EXPORT_PREFIX))
|
== 0
|
== 0
|
&& name[strlen (DLL_EXPORT_PREFIX)] == FASTCALL_PREFIX))
|
&& name[strlen (DLL_EXPORT_PREFIX)] == FASTCALL_PREFIX))
|
/* A fastcall symbol. */
|
/* A fastcall symbol. */
|
{
|
{
|
fprintf (stream, "%s",
|
fprintf (stream, "%s",
|
i386_pe_strip_name_encoding (name));
|
i386_pe_strip_name_encoding (name));
|
}
|
}
|
else
|
else
|
/* Everything else. */
|
/* Everything else. */
|
{
|
{
|
fprintf (stream, "%s%s", USER_LABEL_PREFIX,
|
fprintf (stream, "%s%s", USER_LABEL_PREFIX,
|
i386_pe_strip_name_encoding (name));
|
i386_pe_strip_name_encoding (name));
|
}
|
}
|
}
|
}
|
|
|
void
|
void
|
i386_pe_unique_section (tree decl, int reloc)
|
i386_pe_unique_section (tree decl, int reloc)
|
{
|
{
|
int len;
|
int len;
|
const char *name, *prefix;
|
const char *name, *prefix;
|
char *string;
|
char *string;
|
|
|
name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
|
name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
|
name = i386_pe_strip_name_encoding_full (name);
|
name = i386_pe_strip_name_encoding_full (name);
|
|
|
/* The object is put in, for example, section .text$foo.
|
/* The object is put in, for example, section .text$foo.
|
The linker will then ultimately place them in .text
|
The linker will then ultimately place them in .text
|
(everything from the $ on is stripped). Don't put
|
(everything from the $ on is stripped). Don't put
|
read-only data in .rdata section to avoid a PE linker
|
read-only data in .rdata section to avoid a PE linker
|
bug when .rdata$* grouped sections are used in code
|
bug when .rdata$* grouped sections are used in code
|
without a .rdata section. */
|
without a .rdata section. */
|
if (TREE_CODE (decl) == FUNCTION_DECL)
|
if (TREE_CODE (decl) == FUNCTION_DECL)
|
prefix = ".text$";
|
prefix = ".text$";
|
else if (decl_readonly_section (decl, reloc))
|
else if (decl_readonly_section (decl, reloc))
|
prefix = ".rdata$";
|
prefix = ".rdata$";
|
else
|
else
|
prefix = ".data$";
|
prefix = ".data$";
|
len = strlen (name) + strlen (prefix);
|
len = strlen (name) + strlen (prefix);
|
string = alloca (len + 1);
|
string = alloca (len + 1);
|
sprintf (string, "%s%s", prefix, name);
|
sprintf (string, "%s%s", prefix, name);
|
|
|
DECL_SECTION_NAME (decl) = build_string (len, string);
|
DECL_SECTION_NAME (decl) = build_string (len, string);
|
}
|
}
|
|
|
/* Select a set of attributes for section NAME based on the properties
|
/* Select a set of attributes for section NAME based on the properties
|
of DECL and whether or not RELOC indicates that DECL's initializer
|
of DECL and whether or not RELOC indicates that DECL's initializer
|
might contain runtime relocations.
|
might contain runtime relocations.
|
|
|
We make the section read-only and executable for a function decl,
|
We make the section read-only and executable for a function decl,
|
read-only for a const data decl, and writable for a non-const data decl.
|
read-only for a const data decl, and writable for a non-const data decl.
|
|
|
If the section has already been defined, to not allow it to have
|
If the section has already been defined, to not allow it to have
|
different attributes, as (1) this is ambiguous since we're not seeing
|
different attributes, as (1) this is ambiguous since we're not seeing
|
all the declarations up front and (2) some assemblers (e.g. SVR4)
|
all the declarations up front and (2) some assemblers (e.g. SVR4)
|
do not recognize section redefinitions. */
|
do not recognize section redefinitions. */
|
/* ??? This differs from the "standard" PE implementation in that we
|
/* ??? This differs from the "standard" PE implementation in that we
|
handle the SHARED variable attribute. Should this be done for all
|
handle the SHARED variable attribute. Should this be done for all
|
PE targets? */
|
PE targets? */
|
|
|
#define SECTION_PE_SHARED SECTION_MACH_DEP
|
#define SECTION_PE_SHARED SECTION_MACH_DEP
|
|
|
unsigned int
|
unsigned int
|
i386_pe_section_type_flags (tree decl, const char *name, int reloc)
|
i386_pe_section_type_flags (tree decl, const char *name, int reloc)
|
{
|
{
|
static htab_t htab;
|
static htab_t htab;
|
unsigned int flags;
|
unsigned int flags;
|
unsigned int **slot;
|
unsigned int **slot;
|
|
|
/* The names we put in the hashtable will always be the unique
|
/* The names we put in the hashtable will always be the unique
|
versions given to us by the stringtable, so we can just use
|
versions given to us by the stringtable, so we can just use
|
their addresses as the keys. */
|
their addresses as the keys. */
|
if (!htab)
|
if (!htab)
|
htab = htab_create (31, htab_hash_pointer, htab_eq_pointer, NULL);
|
htab = htab_create (31, htab_hash_pointer, htab_eq_pointer, NULL);
|
|
|
if (decl && TREE_CODE (decl) == FUNCTION_DECL)
|
if (decl && TREE_CODE (decl) == FUNCTION_DECL)
|
flags = SECTION_CODE;
|
flags = SECTION_CODE;
|
else if (decl && decl_readonly_section (decl, reloc))
|
else if (decl && decl_readonly_section (decl, reloc))
|
flags = 0;
|
flags = 0;
|
else
|
else
|
{
|
{
|
flags = SECTION_WRITE;
|
flags = SECTION_WRITE;
|
|
|
if (decl && TREE_CODE (decl) == VAR_DECL
|
if (decl && TREE_CODE (decl) == VAR_DECL
|
&& lookup_attribute ("shared", DECL_ATTRIBUTES (decl)))
|
&& lookup_attribute ("shared", DECL_ATTRIBUTES (decl)))
|
flags |= SECTION_PE_SHARED;
|
flags |= SECTION_PE_SHARED;
|
}
|
}
|
|
|
if (decl && DECL_ONE_ONLY (decl))
|
if (decl && DECL_ONE_ONLY (decl))
|
flags |= SECTION_LINKONCE;
|
flags |= SECTION_LINKONCE;
|
|
|
/* See if we already have an entry for this section. */
|
/* See if we already have an entry for this section. */
|
slot = (unsigned int **) htab_find_slot (htab, name, INSERT);
|
slot = (unsigned int **) htab_find_slot (htab, name, INSERT);
|
if (!*slot)
|
if (!*slot)
|
{
|
{
|
*slot = (unsigned int *) xmalloc (sizeof (unsigned int));
|
*slot = (unsigned int *) xmalloc (sizeof (unsigned int));
|
**slot = flags;
|
**slot = flags;
|
}
|
}
|
else
|
else
|
{
|
{
|
if (decl && **slot != flags)
|
if (decl && **slot != flags)
|
error ("%q+D causes a section type conflict", decl);
|
error ("%q+D causes a section type conflict", decl);
|
}
|
}
|
|
|
return flags;
|
return flags;
|
}
|
}
|
|
|
void
|
void
|
i386_pe_asm_named_section (const char *name, unsigned int flags,
|
i386_pe_asm_named_section (const char *name, unsigned int flags,
|
tree decl)
|
tree decl)
|
{
|
{
|
char flagchars[8], *f = flagchars;
|
char flagchars[8], *f = flagchars;
|
|
|
if ((flags & (SECTION_CODE | SECTION_WRITE)) == 0)
|
if ((flags & (SECTION_CODE | SECTION_WRITE)) == 0)
|
/* readonly data */
|
/* readonly data */
|
{
|
{
|
*f++ ='d'; /* This is necessary for older versions of gas. */
|
*f++ ='d'; /* This is necessary for older versions of gas. */
|
*f++ ='r';
|
*f++ ='r';
|
}
|
}
|
else
|
else
|
{
|
{
|
if (flags & SECTION_CODE)
|
if (flags & SECTION_CODE)
|
*f++ = 'x';
|
*f++ = 'x';
|
if (flags & SECTION_WRITE)
|
if (flags & SECTION_WRITE)
|
*f++ = 'w';
|
*f++ = 'w';
|
if (flags & SECTION_PE_SHARED)
|
if (flags & SECTION_PE_SHARED)
|
*f++ = 's';
|
*f++ = 's';
|
}
|
}
|
|
|
*f = '\0';
|
*f = '\0';
|
|
|
fprintf (asm_out_file, "\t.section\t%s,\"%s\"\n", name, flagchars);
|
fprintf (asm_out_file, "\t.section\t%s,\"%s\"\n", name, flagchars);
|
|
|
if (flags & SECTION_LINKONCE)
|
if (flags & SECTION_LINKONCE)
|
{
|
{
|
/* Functions may have been compiled at various levels of
|
/* Functions may have been compiled at various levels of
|
optimization so we can't use `same_size' here.
|
optimization so we can't use `same_size' here.
|
Instead, have the linker pick one, without warning.
|
Instead, have the linker pick one, without warning.
|
If 'selectany' attribute has been specified, MS compiler
|
If 'selectany' attribute has been specified, MS compiler
|
sets 'discard' characteristic, rather than telling linker
|
sets 'discard' characteristic, rather than telling linker
|
to warn of size or content mismatch, so do the same. */
|
to warn of size or content mismatch, so do the same. */
|
bool discard = (flags & SECTION_CODE)
|
bool discard = (flags & SECTION_CODE)
|
|| lookup_attribute ("selectany",
|
|| lookup_attribute ("selectany",
|
DECL_ATTRIBUTES (decl));
|
DECL_ATTRIBUTES (decl));
|
fprintf (asm_out_file, "\t.linkonce %s\n",
|
fprintf (asm_out_file, "\t.linkonce %s\n",
|
(discard ? "discard" : "same_size"));
|
(discard ? "discard" : "same_size"));
|
}
|
}
|
}
|
}
|
|
|
/* The Microsoft linker requires that every function be marked as
|
/* The Microsoft linker requires that every function be marked as
|
DT_FCN. When using gas on cygwin, we must emit appropriate .type
|
DT_FCN. When using gas on cygwin, we must emit appropriate .type
|
directives. */
|
directives. */
|
|
|
#include "gsyms.h"
|
#include "gsyms.h"
|
|
|
/* Mark a function appropriately. This should only be called for
|
/* Mark a function appropriately. This should only be called for
|
functions for which we are not emitting COFF debugging information.
|
functions for which we are not emitting COFF debugging information.
|
FILE is the assembler output file, NAME is the name of the
|
FILE is the assembler output file, NAME is the name of the
|
function, and PUBLIC is nonzero if the function is globally
|
function, and PUBLIC is nonzero if the function is globally
|
visible. */
|
visible. */
|
|
|
void
|
void
|
i386_pe_declare_function_type (FILE *file, const char *name, int public)
|
i386_pe_declare_function_type (FILE *file, const char *name, int public)
|
{
|
{
|
fprintf (file, "\t.def\t");
|
fprintf (file, "\t.def\t");
|
assemble_name (file, name);
|
assemble_name (file, name);
|
fprintf (file, ";\t.scl\t%d;\t.type\t%d;\t.endef\n",
|
fprintf (file, ";\t.scl\t%d;\t.type\t%d;\t.endef\n",
|
public ? (int) C_EXT : (int) C_STAT,
|
public ? (int) C_EXT : (int) C_STAT,
|
(int) DT_FCN << N_BTSHFT);
|
(int) DT_FCN << N_BTSHFT);
|
}
|
}
|
|
|
/* Keep a list of external functions. */
|
/* Keep a list of external functions. */
|
|
|
struct extern_list GTY(())
|
struct extern_list GTY(())
|
{
|
{
|
struct extern_list *next;
|
struct extern_list *next;
|
tree decl;
|
tree decl;
|
const char *name;
|
const char *name;
|
};
|
};
|
|
|
static GTY(()) struct extern_list *extern_head;
|
static GTY(()) struct extern_list *extern_head;
|
|
|
/* Assemble an external function reference. We need to keep a list of
|
/* 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
|
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
|
assembly. We can't output the types now, because we might see a
|
definition of the function later on and emit debugging information
|
definition of the function later on and emit debugging information
|
for it then. */
|
for it then. */
|
|
|
void
|
void
|
i386_pe_record_external_function (tree decl, const char *name)
|
i386_pe_record_external_function (tree decl, const char *name)
|
{
|
{
|
struct extern_list *p;
|
struct extern_list *p;
|
|
|
p = (struct extern_list *) ggc_alloc (sizeof *p);
|
p = (struct extern_list *) ggc_alloc (sizeof *p);
|
p->next = extern_head;
|
p->next = extern_head;
|
p->decl = decl;
|
p->decl = decl;
|
p->name = name;
|
p->name = name;
|
extern_head = p;
|
extern_head = p;
|
}
|
}
|
|
|
/* Keep a list of exported symbols. */
|
/* Keep a list of exported symbols. */
|
|
|
struct export_list GTY(())
|
struct export_list GTY(())
|
{
|
{
|
struct export_list *next;
|
struct export_list *next;
|
const char *name;
|
const char *name;
|
int is_data; /* used to type tag exported symbols. */
|
int is_data; /* used to type tag exported symbols. */
|
};
|
};
|
|
|
static GTY(()) struct export_list *export_head;
|
static GTY(()) struct export_list *export_head;
|
|
|
/* Assemble an export symbol entry. We need to keep a list of
|
/* 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
|
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,
|
assembly. We used to output these export symbols in each function,
|
but that causes problems with GNU ld when the sections are
|
but that causes problems with GNU ld when the sections are
|
linkonce. */
|
linkonce. */
|
|
|
void
|
void
|
i386_pe_record_exported_symbol (const char *name, int is_data)
|
i386_pe_record_exported_symbol (const char *name, int is_data)
|
{
|
{
|
struct export_list *p;
|
struct export_list *p;
|
|
|
p = (struct export_list *) ggc_alloc (sizeof *p);
|
p = (struct export_list *) ggc_alloc (sizeof *p);
|
p->next = export_head;
|
p->next = export_head;
|
p->name = name;
|
p->name = name;
|
p->is_data = is_data;
|
p->is_data = is_data;
|
export_head = p;
|
export_head = p;
|
}
|
}
|
|
|
/* This is called at the end of assembly. For each external function
|
/* This is called at the end of assembly. For each external function
|
which has not been defined, we output a declaration now. We also
|
which has not been defined, we output a declaration now. We also
|
output the .drectve section. */
|
output the .drectve section. */
|
|
|
void
|
void
|
i386_pe_file_end (void)
|
i386_pe_file_end (void)
|
{
|
{
|
struct extern_list *p;
|
struct extern_list *p;
|
|
|
ix86_file_end ();
|
ix86_file_end ();
|
|
|
for (p = extern_head; p != NULL; p = p->next)
|
for (p = extern_head; p != NULL; p = p->next)
|
{
|
{
|
tree decl;
|
tree decl;
|
|
|
decl = p->decl;
|
decl = p->decl;
|
|
|
/* Positively ensure only one declaration for any given symbol. */
|
/* Positively ensure only one declaration for any given symbol. */
|
if (! TREE_ASM_WRITTEN (decl)
|
if (! TREE_ASM_WRITTEN (decl)
|
&& TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
|
&& TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
|
{
|
{
|
TREE_ASM_WRITTEN (decl) = 1;
|
TREE_ASM_WRITTEN (decl) = 1;
|
i386_pe_declare_function_type (asm_out_file, p->name,
|
i386_pe_declare_function_type (asm_out_file, p->name,
|
TREE_PUBLIC (decl));
|
TREE_PUBLIC (decl));
|
}
|
}
|
}
|
}
|
|
|
if (export_head)
|
if (export_head)
|
{
|
{
|
struct export_list *q;
|
struct export_list *q;
|
drectve_section ();
|
drectve_section ();
|
for (q = export_head; q != NULL; q = q->next)
|
for (q = export_head; q != NULL; q = q->next)
|
{
|
{
|
fprintf (asm_out_file, "\t.ascii \" -export:%s%s\"\n",
|
fprintf (asm_out_file, "\t.ascii \" -export:%s%s\"\n",
|
i386_pe_strip_name_encoding (q->name),
|
i386_pe_strip_name_encoding (q->name),
|
(q->is_data) ? ",data" : "");
|
(q->is_data) ? ",data" : "");
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
#include "gt-winnt.h"
|
#include "gt-winnt.h"
|
|
|
