/* Routines for GCC for a Symbian OS targeted SH backend.
|
/* Routines for GCC for a Symbian OS targeted SH backend.
|
Copyright (C) 2004, 2005, 2007 Free Software Foundation, Inc.
|
Copyright (C) 2004, 2005, 2007 Free Software Foundation, Inc.
|
Contributed by RedHat.
|
Contributed by RedHat.
|
Most of this code is stolen from i386/winnt.c.
|
Most of this code is stolen from i386/winnt.c.
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify it
|
GCC is free software; you can redistribute it and/or modify it
|
under the terms of the GNU General Public License as published
|
under the terms of the GNU General Public License as published
|
by the Free Software Foundation; either version 3, or (at your
|
by the Free Software Foundation; either version 3, or (at your
|
option) any later version.
|
option) any later version.
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT
|
GCC is distributed in the hope that it will be useful, but WITHOUT
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
|
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
|
License for more details.
|
License 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 "output.h"
|
#include "output.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "tree.h"
|
#include "tree.h"
|
#include "expr.h"
|
#include "expr.h"
|
#include "tm_p.h"
|
#include "tm_p.h"
|
#include "cp/cp-tree.h" /* We need access to the OVL_... macros. */
|
#include "cp/cp-tree.h" /* We need access to the OVL_... macros. */
|
#include "toplev.h"
|
#include "toplev.h"
|
|
|
/* Select the level of debugging information to display.
|
/* Select the level of debugging information to display.
|
0 for no debugging.
|
0 for no debugging.
|
1 for informative messages about decisions to add attributes
|
1 for informative messages about decisions to add attributes
|
2 for verbose information about what is being done. */
|
2 for verbose information about what is being done. */
|
#define SYMBIAN_DEBUG 0
|
#define SYMBIAN_DEBUG 0
|
/* #define SYMBIAN_DEBUG 1 */
|
/* #define SYMBIAN_DEBUG 1 */
|
/* #define SYMBIAN_DEBUG 2 */
|
/* #define SYMBIAN_DEBUG 2 */
|
|
|
/* A unique character to encode declspec encoded objects. */
|
/* A unique character to encode declspec encoded objects. */
|
#define SH_SYMBIAN_FLAG_CHAR "$"
|
#define SH_SYMBIAN_FLAG_CHAR "$"
|
|
|
/* Unique strings to prefix exported and imported objects. */
|
/* Unique strings to prefix exported and imported objects. */
|
#define DLL_IMPORT_PREFIX SH_SYMBIAN_FLAG_CHAR "i."
|
#define DLL_IMPORT_PREFIX SH_SYMBIAN_FLAG_CHAR "i."
|
#define DLL_EXPORT_PREFIX SH_SYMBIAN_FLAG_CHAR "e."
|
#define DLL_EXPORT_PREFIX SH_SYMBIAN_FLAG_CHAR "e."
|
|
|
|
|
/* 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
|
sh_symbian_associated_type (tree decl)
|
sh_symbian_associated_type (tree decl)
|
{
|
{
|
tree t = NULL_TREE;
|
tree t = NULL_TREE;
|
|
|
if (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
|
if (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
|
/* Methods now inherit their dllimport/dllexport attributes correctly
|
/* Methods now inherit their dllimport/dllexport attributes correctly
|
so there is no need to check their class. In fact it is wrong to
|
so there is no need to check their class. In fact it is wrong to
|
check their class since a method can remain unexported from an
|
check their class since a method can remain unexported from an
|
exported class. */
|
exported class. */
|
return t;
|
return t;
|
|
|
/* Otherwise we can just take the DECL_CONTEXT as normal. */
|
/* Otherwise we can just take the DECL_CONTEXT as normal. */
|
if (DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl)))
|
if (DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl)))
|
t = DECL_CONTEXT (decl);
|
t = DECL_CONTEXT (decl);
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
/* Return nonzero if DECL is a dllexport'd object. */
|
/* Return nonzero if DECL is a dllexport'd object. */
|
|
|
bool
|
bool
|
sh_symbian_dllexport_p (tree decl)
|
sh_symbian_dllexport_p (tree decl)
|
{
|
{
|
tree exp;
|
tree exp;
|
|
|
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;
|
|
|
exp = lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl));
|
exp = lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl));
|
|
|
/* Class members get the dllexport status of their class. */
|
/* Class members get the dllexport status of their class. */
|
if (exp == NULL)
|
if (exp == NULL)
|
{
|
{
|
tree class = sh_symbian_associated_type (decl);
|
tree class = sh_symbian_associated_type (decl);
|
|
|
if (class)
|
if (class)
|
exp = lookup_attribute ("dllexport", TYPE_ATTRIBUTES (class));
|
exp = lookup_attribute ("dllexport", TYPE_ATTRIBUTES (class));
|
}
|
}
|
#if SYMBIAN_DEBUG
|
#if SYMBIAN_DEBUG
|
if (exp)
|
if (exp)
|
{
|
{
|
print_node_brief (stderr, "dllexport:", decl, 0);
|
print_node_brief (stderr, "dllexport:", decl, 0);
|
fprintf (stderr, "\n");
|
fprintf (stderr, "\n");
|
}
|
}
|
else
|
else
|
#if SYMBIAN_DEBUG < 2
|
#if SYMBIAN_DEBUG < 2
|
if (TREE_CODE (decl) != FUNCTION_DECL)
|
if (TREE_CODE (decl) != FUNCTION_DECL)
|
#endif
|
#endif
|
{
|
{
|
print_node_brief (stderr, "no dllexport:", decl, 0);
|
print_node_brief (stderr, "no dllexport:", decl, 0);
|
fprintf (stderr, "\n");
|
fprintf (stderr, "\n");
|
}
|
}
|
#endif
|
#endif
|
return exp ? true : false;
|
return exp ? true : false;
|
}
|
}
|
|
|
/* Return nonzero if DECL is a dllimport'd object. */
|
/* Return nonzero if DECL is a dllimport'd object. */
|
|
|
static bool
|
static bool
|
sh_symbian_dllimport_p (tree decl)
|
sh_symbian_dllimport_p (tree decl)
|
{
|
{
|
tree imp;
|
tree imp;
|
|
|
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;
|
|
|
imp = lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl));
|
imp = lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl));
|
if (imp)
|
if (imp)
|
return true;
|
return true;
|
|
|
/* Class members get the dllimport status of their class. */
|
/* Class members get the dllimport status of their class. */
|
imp = sh_symbian_associated_type (decl);
|
imp = sh_symbian_associated_type (decl);
|
if (! imp)
|
if (! imp)
|
return false;
|
return false;
|
|
|
imp = lookup_attribute ("dllimport", TYPE_ATTRIBUTES (imp));
|
imp = lookup_attribute ("dllimport", TYPE_ATTRIBUTES (imp));
|
if (!imp)
|
if (!imp)
|
return false;
|
return false;
|
|
|
/* Don't mark defined functions as dllimport. If the definition itself
|
/* Don't mark defined functions as dllimport. If the definition itself
|
was marked with dllimport, then sh_symbian_handle_dll_attribute reports
|
was marked with dllimport, then sh_symbian_handle_dll_attribute reports
|
an error. This handles the case when the definition overrides an
|
an error. This handles the case when the definition overrides an
|
earlier declaration. */
|
earlier declaration. */
|
if (TREE_CODE (decl) == FUNCTION_DECL
|
if (TREE_CODE (decl) == FUNCTION_DECL
|
&& DECL_INITIAL (decl)
|
&& DECL_INITIAL (decl)
|
&& !DECL_INLINE (decl))
|
&& !DECL_INLINE (decl))
|
{
|
{
|
/* Don't warn about artificial methods. */
|
/* Don't warn about artificial methods. */
|
if (!DECL_ARTIFICIAL (decl))
|
if (!DECL_ARTIFICIAL (decl))
|
warning (OPT_Wattributes, "function %q+D is defined after prior "
|
warning (OPT_Wattributes, "function %q+D is defined after prior "
|
"declaration as dllimport: attribute ignored",
|
"declaration as dllimport: attribute ignored",
|
decl);
|
decl);
|
return false;
|
return false;
|
}
|
}
|
|
|
/* We ignore the dllimport attribute for inline member functions.
|
/* We ignore the dllimport attribute for inline member functions.
|
This differs from MSVC behavior which treats it like GNUC
|
This differs from MSVC behavior which treats it like GNUC
|
'extern inline' extension. */
|
'extern inline' extension. */
|
else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_INLINE (decl))
|
else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_INLINE (decl))
|
{
|
{
|
if (extra_warnings)
|
if (extra_warnings)
|
warning (OPT_Wattributes, "inline function %q+D is declared as "
|
warning (OPT_Wattributes, "inline function %q+D is declared as "
|
"dllimport: attribute ignored",
|
"dllimport: attribute ignored",
|
decl);
|
decl);
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Don't allow definitions of static data members in dllimport
|
/* Don't allow definitions of static data members in dllimport
|
class. Just ignore the attribute for vtable data. */
|
class. Just ignore the attribute for vtable data. */
|
else if (TREE_CODE (decl) == VAR_DECL
|
else if (TREE_CODE (decl) == VAR_DECL
|
&& TREE_STATIC (decl)
|
&& TREE_STATIC (decl)
|
&& TREE_PUBLIC (decl)
|
&& TREE_PUBLIC (decl)
|
&& !DECL_EXTERNAL (decl))
|
&& !DECL_EXTERNAL (decl))
|
{
|
{
|
if (!DECL_VIRTUAL_P (decl))
|
if (!DECL_VIRTUAL_P (decl))
|
error ("definition of static data member %q+D of dllimport'd class",
|
error ("definition of static data member %q+D of dllimport'd class",
|
decl);
|
decl);
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Since we can't treat a pointer to a dllimport'd symbol as a
|
/* Since we can't treat a pointer to a dllimport'd symbol as a
|
constant address, we turn off the attribute on C++ virtual
|
constant address, we turn off the attribute on C++ virtual
|
methods to allow creation of vtables using thunks. Don't mark
|
methods to allow creation of vtables using thunks. Don't mark
|
artificial methods either (in sh_symbian_associated_type, only
|
artificial methods either (in sh_symbian_associated_type, only
|
COMDAT artificial method get import status from class context). */
|
COMDAT artificial method get import status from class context). */
|
else if (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE
|
else if (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE
|
&& (DECL_VIRTUAL_P (decl) || DECL_ARTIFICIAL (decl)))
|
&& (DECL_VIRTUAL_P (decl) || DECL_ARTIFICIAL (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. */
|
|
|
bool
|
bool
|
sh_symbian_dllexport_name_p (const char *symbol)
|
sh_symbian_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. */
|
|
|
|
|
bool
|
bool
|
sh_symbian_dllimport_name_p (const char *symbol)
|
sh_symbian_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
|
sh_symbian_mark_dllexport (tree decl)
|
sh_symbian_mark_dllexport (tree decl)
|
{
|
{
|
const char *oldname;
|
const char *oldname;
|
char *newname;
|
char *newname;
|
rtx rtlname;
|
rtx rtlname;
|
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 (sh_symbian_dllimport_name_p (oldname))
|
if (sh_symbian_dllimport_name_p (oldname))
|
{
|
{
|
/* Remove DLL_IMPORT_PREFIX.
|
/* Remove DLL_IMPORT_PREFIX.
|
Note - we do not issue a warning here. In Symbian's environment it
|
Note - we do not issue a warning here. In Symbian's environment it
|
is legitimate for a prototype to be marked as dllimport and the
|
is legitimate for a prototype to be marked as dllimport and the
|
corresponding definition to be marked as dllexport. The prototypes
|
corresponding definition to be marked as dllexport. The prototypes
|
are in headers used everywhere and the definition is in a translation
|
are in headers used everywhere and the definition is in a translation
|
unit which has included the header in order to ensure argument
|
unit which has included the header in order to ensure argument
|
correctness. */
|
correctness. */
|
oldname += strlen (DLL_IMPORT_PREFIX);
|
oldname += strlen (DLL_IMPORT_PREFIX);
|
DECL_DLLIMPORT_P (decl) = 0;
|
DECL_DLLIMPORT_P (decl) = 0;
|
}
|
}
|
else if (sh_symbian_dllexport_name_p (oldname))
|
else if (sh_symbian_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);
|
|
|
XEXP (DECL_RTL (decl), 0) =
|
XEXP (DECL_RTL (decl), 0) =
|
gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (idp));
|
gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (idp));
|
}
|
}
|
|
|
/* Mark a DECL as being dllimport'd. */
|
/* Mark a DECL as being dllimport'd. */
|
|
|
static void
|
static void
|
sh_symbian_mark_dllimport (tree decl)
|
sh_symbian_mark_dllimport (tree decl)
|
{
|
{
|
const char *oldname;
|
const char *oldname;
|
char *newname;
|
char *newname;
|
tree idp;
|
tree idp;
|
rtx rtlname;
|
rtx rtlname;
|
rtx newrtl;
|
rtx newrtl;
|
|
|
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 (sh_symbian_dllexport_name_p (oldname))
|
if (sh_symbian_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)));
|
}
|
}
|
else if (sh_symbian_dllimport_name_p (oldname))
|
else if (sh_symbian_dllimport_name_p (oldname))
|
{
|
{
|
/* Already done, but do a sanity check to prevent assembler errors. */
|
/* Already done, but do a sanity check to prevent assembler errors. */
|
if (!DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl))
|
if (!DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl))
|
error ("failure in redeclaration of %q+D: dllimport'd symbol lacks external linkage",
|
error ("failure in redeclaration of %q+D: dllimport'd symbol lacks external linkage",
|
decl);
|
decl);
|
}
|
}
|
else
|
else
|
{
|
{
|
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);
|
newrtl = gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (idp));
|
newrtl = gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (idp));
|
XEXP (DECL_RTL (decl), 0) = newrtl;
|
XEXP (DECL_RTL (decl), 0) = newrtl;
|
}
|
}
|
}
|
}
|
|
|
void
|
void
|
sh_symbian_encode_section_info (tree decl, rtx rtl, int first)
|
sh_symbian_encode_section_info (tree decl, rtx rtl, int first)
|
{
|
{
|
default_encode_section_info (decl, rtl, first);
|
default_encode_section_info (decl, rtl, first);
|
|
|
/* Mark the decl so we can tell from the rtl whether
|
/* Mark the decl so we can tell from the rtl whether
|
the object is dllexport'd or dllimport'd. */
|
the object is dllexport'd or dllimport'd. */
|
if (sh_symbian_dllexport_p (decl))
|
if (sh_symbian_dllexport_p (decl))
|
sh_symbian_mark_dllexport (decl);
|
sh_symbian_mark_dllexport (decl);
|
else if (sh_symbian_dllimport_p (decl))
|
else if (sh_symbian_dllimport_p (decl))
|
sh_symbian_mark_dllimport (decl);
|
sh_symbian_mark_dllimport (decl);
|
/* It might be that DECL has already been marked as dllimport, but a
|
/* It might be that DECL has already been marked as dllimport, but a
|
subsequent definition nullified that. The attribute is gone but
|
subsequent definition nullified that. The attribute is gone but
|
DECL_RTL still has (DLL_IMPORT_PREFIX) prefixed. We need to remove
|
DECL_RTL still has (DLL_IMPORT_PREFIX) prefixed. We need to remove
|
that. Ditto for the DECL_DLLIMPORT_P flag. */
|
that. Ditto for the DECL_DLLIMPORT_P flag. */
|
else if ( (TREE_CODE (decl) == FUNCTION_DECL
|
else if ( (TREE_CODE (decl) == FUNCTION_DECL
|
|| TREE_CODE (decl) == VAR_DECL)
|
|| TREE_CODE (decl) == VAR_DECL)
|
&& DECL_RTL (decl) != NULL_RTX
|
&& DECL_RTL (decl) != NULL_RTX
|
&& GET_CODE (DECL_RTL (decl)) == MEM
|
&& GET_CODE (DECL_RTL (decl)) == MEM
|
&& GET_CODE (XEXP (DECL_RTL (decl), 0)) == MEM
|
&& GET_CODE (XEXP (DECL_RTL (decl), 0)) == MEM
|
&& GET_CODE (XEXP (XEXP (DECL_RTL (decl), 0), 0)) == SYMBOL_REF
|
&& GET_CODE (XEXP (XEXP (DECL_RTL (decl), 0), 0)) == SYMBOL_REF
|
&& sh_symbian_dllimport_name_p (XSTR (XEXP (XEXP (DECL_RTL (decl), 0), 0), 0)))
|
&& sh_symbian_dllimport_name_p (XSTR (XEXP (XEXP (DECL_RTL (decl), 0), 0), 0)))
|
{
|
{
|
const char * oldname = XSTR (XEXP (XEXP (DECL_RTL (decl), 0), 0), 0);
|
const char * oldname = XSTR (XEXP (XEXP (DECL_RTL (decl), 0), 0), 0);
|
/* Remove DLL_IMPORT_PREFIX. */
|
/* Remove DLL_IMPORT_PREFIX. */
|
tree idp = get_identifier (oldname + strlen (DLL_IMPORT_PREFIX));
|
tree idp = get_identifier (oldname + strlen (DLL_IMPORT_PREFIX));
|
rtx newrtl = gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (idp));
|
rtx newrtl = gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (idp));
|
|
|
warning (0, "%s %q+D %s after being referenced with dllimport linkage",
|
warning (0, "%s %q+D %s after being referenced with dllimport linkage",
|
TREE_CODE (decl) == VAR_DECL ? "variable" : "function",
|
TREE_CODE (decl) == VAR_DECL ? "variable" : "function",
|
decl, (DECL_INITIAL (decl) || !DECL_EXTERNAL (decl))
|
decl, (DECL_INITIAL (decl) || !DECL_EXTERNAL (decl))
|
? "defined locally" : "redeclared without dllimport attribute");
|
? "defined locally" : "redeclared without dllimport attribute");
|
|
|
XEXP (DECL_RTL (decl), 0) = newrtl;
|
XEXP (DECL_RTL (decl), 0) = newrtl;
|
|
|
DECL_DLLIMPORT_P (decl) = 0;
|
DECL_DLLIMPORT_P (decl) = 0;
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Return the length of a function name prefix
|
/* Return the length of a function name prefix
|
that starts with the character 'c'. */
|
that starts with the character 'c'. */
|
|
|
static int
|
static int
|
sh_symbian_get_strip_length (int c)
|
sh_symbian_get_strip_length (int c)
|
{
|
{
|
/* XXX Assumes strlen (DLL_EXPORT_PREFIX) == strlen (DLL_IMPORT_PREFIX). */
|
/* XXX Assumes strlen (DLL_EXPORT_PREFIX) == strlen (DLL_IMPORT_PREFIX). */
|
return (c == SH_SYMBIAN_FLAG_CHAR[0]) ? strlen (DLL_EXPORT_PREFIX) : 0;
|
return (c == SH_SYMBIAN_FLAG_CHAR[0]) ? strlen (DLL_EXPORT_PREFIX) : 0;
|
}
|
}
|
|
|
/* Return a pointer to a function's name with any
|
/* Return a pointer to a function's name with any
|
and all prefix encodings stripped from it. */
|
and all prefix encodings stripped from it. */
|
|
|
const char *
|
const char *
|
sh_symbian_strip_name_encoding (const char *name)
|
sh_symbian_strip_name_encoding (const char *name)
|
{
|
{
|
int skip;
|
int skip;
|
|
|
while ((skip = sh_symbian_get_strip_length (*name)))
|
while ((skip = sh_symbian_get_strip_length (*name)))
|
name += skip;
|
name += skip;
|
|
|
return name;
|
return name;
|
}
|
}
|
|
|
/* Add the named attribute to the given node. Copes with both DECLs and
|
/* Add the named attribute to the given node. Copes with both DECLs and
|
TYPEs. Will only add the attribute if it is not already present. */
|
TYPEs. Will only add the attribute if it is not already present. */
|
|
|
static void
|
static void
|
symbian_add_attribute (tree node, const char *attr_name)
|
symbian_add_attribute (tree node, const char *attr_name)
|
{
|
{
|
tree attrs;
|
tree attrs;
|
tree attr;
|
tree attr;
|
|
|
attrs = DECL_P (node) ? DECL_ATTRIBUTES (node) : TYPE_ATTRIBUTES (node);
|
attrs = DECL_P (node) ? DECL_ATTRIBUTES (node) : TYPE_ATTRIBUTES (node);
|
|
|
if (lookup_attribute (attr_name, attrs) != NULL_TREE)
|
if (lookup_attribute (attr_name, attrs) != NULL_TREE)
|
return;
|
return;
|
|
|
attr = get_identifier (attr_name);
|
attr = get_identifier (attr_name);
|
|
|
if (DECL_P (node))
|
if (DECL_P (node))
|
DECL_ATTRIBUTES (node) = tree_cons (attr, NULL_TREE, attrs);
|
DECL_ATTRIBUTES (node) = tree_cons (attr, NULL_TREE, attrs);
|
else
|
else
|
TYPE_ATTRIBUTES (node) = tree_cons (attr, NULL_TREE, attrs);
|
TYPE_ATTRIBUTES (node) = tree_cons (attr, NULL_TREE, attrs);
|
|
|
#if SYMBIAN_DEBUG
|
#if SYMBIAN_DEBUG
|
fprintf (stderr, "propogate %s attribute", attr_name);
|
fprintf (stderr, "propogate %s attribute", attr_name);
|
print_node_brief (stderr, " to", node, 0);
|
print_node_brief (stderr, " to", node, 0);
|
fprintf (stderr, "\n");
|
fprintf (stderr, "\n");
|
#endif
|
#endif
|
}
|
}
|
|
|
/* Handle a "dllimport" or "dllexport" attribute;
|
/* Handle a "dllimport" or "dllexport" attribute;
|
arguments as in struct attribute_spec.handler. */
|
arguments as in struct attribute_spec.handler. */
|
|
|
tree
|
tree
|
sh_symbian_handle_dll_attribute (tree *pnode, tree name, tree args,
|
sh_symbian_handle_dll_attribute (tree *pnode, tree name, tree args,
|
int flags, bool *no_add_attrs)
|
int flags, bool *no_add_attrs)
|
{
|
{
|
tree thunk;
|
tree thunk;
|
tree node = *pnode;
|
tree node = *pnode;
|
const char *attr = IDENTIFIER_POINTER (name);
|
const char *attr = IDENTIFIER_POINTER (name);
|
|
|
/* These attributes may apply to structure and union types being
|
/* These attributes may apply to structure and union types being
|
created, but otherwise should pass to the declaration involved. */
|
created, but otherwise should pass to the declaration involved. */
|
if (!DECL_P (node))
|
if (!DECL_P (node))
|
{
|
{
|
if (flags & ((int) ATTR_FLAG_DECL_NEXT
|
if (flags & ((int) ATTR_FLAG_DECL_NEXT
|
| (int) ATTR_FLAG_FUNCTION_NEXT
|
| (int) ATTR_FLAG_FUNCTION_NEXT
|
| (int) ATTR_FLAG_ARRAY_NEXT))
|
| (int) ATTR_FLAG_ARRAY_NEXT))
|
{
|
{
|
warning (OPT_Wattributes, "%qs attribute ignored", attr);
|
warning (OPT_Wattributes, "%qs attribute ignored", attr);
|
*no_add_attrs = true;
|
*no_add_attrs = true;
|
return tree_cons (name, args, NULL_TREE);
|
return tree_cons (name, args, NULL_TREE);
|
}
|
}
|
|
|
if (TREE_CODE (node) != RECORD_TYPE && TREE_CODE (node) != UNION_TYPE)
|
if (TREE_CODE (node) != RECORD_TYPE && TREE_CODE (node) != UNION_TYPE)
|
{
|
{
|
warning (OPT_Wattributes, "%qs attribute ignored", attr);
|
warning (OPT_Wattributes, "%qs attribute ignored", attr);
|
*no_add_attrs = true;
|
*no_add_attrs = true;
|
}
|
}
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* Report error on dllimport ambiguities
|
/* Report error on dllimport ambiguities
|
seen now before they cause any damage. */
|
seen now before they cause any damage. */
|
else if (is_attribute_p ("dllimport", name))
|
else if (is_attribute_p ("dllimport", name))
|
{
|
{
|
if (TREE_CODE (node) == VAR_DECL)
|
if (TREE_CODE (node) == VAR_DECL)
|
{
|
{
|
if (DECL_INITIAL (node))
|
if (DECL_INITIAL (node))
|
{
|
{
|
error ("variable %q+D definition is marked dllimport",
|
error ("variable %q+D definition is marked dllimport",
|
node);
|
node);
|
*no_add_attrs = true;
|
*no_add_attrs = true;
|
}
|
}
|
|
|
/* `extern' needn't be specified with dllimport.
|
/* `extern' needn't be specified with dllimport.
|
Specify `extern' now and hope for the best. Sigh. */
|
Specify `extern' now and hope for the best. Sigh. */
|
DECL_EXTERNAL (node) = 1;
|
DECL_EXTERNAL (node) = 1;
|
/* Also, implicitly give dllimport'd variables declared within
|
/* Also, implicitly give dllimport'd variables declared within
|
a function global scope, unless declared static. */
|
a function global scope, unless declared static. */
|
if (current_function_decl != NULL_TREE && ! TREE_STATIC (node))
|
if (current_function_decl != NULL_TREE && ! TREE_STATIC (node))
|
TREE_PUBLIC (node) = 1;
|
TREE_PUBLIC (node) = 1;
|
}
|
}
|
}
|
}
|
|
|
/* If the node is an overloaded constructor or destructor, then we must
|
/* If the node is an overloaded constructor or destructor, then we must
|
make sure that the attribute is propagated along the overload chain,
|
make sure that the attribute is propagated along the overload chain,
|
as it is these overloaded functions which will be emitted, rather than
|
as it is these overloaded functions which will be emitted, rather than
|
the user declared constructor itself. */
|
the user declared constructor itself. */
|
if (TREE_CODE (TREE_TYPE (node)) == METHOD_TYPE
|
if (TREE_CODE (TREE_TYPE (node)) == METHOD_TYPE
|
&& (DECL_CONSTRUCTOR_P (node) || DECL_DESTRUCTOR_P (node)))
|
&& (DECL_CONSTRUCTOR_P (node) || DECL_DESTRUCTOR_P (node)))
|
{
|
{
|
tree overload;
|
tree overload;
|
|
|
for (overload = OVL_CHAIN (node); overload; overload = OVL_CHAIN (overload))
|
for (overload = OVL_CHAIN (node); overload; overload = OVL_CHAIN (overload))
|
{
|
{
|
tree node_args;
|
tree node_args;
|
tree func_args;
|
tree func_args;
|
tree function = OVL_CURRENT (overload);
|
tree function = OVL_CURRENT (overload);
|
|
|
if (! function
|
if (! function
|
|| ! DECL_P (function)
|
|| ! DECL_P (function)
|
|| (DECL_CONSTRUCTOR_P (node) && ! DECL_CONSTRUCTOR_P (function))
|
|| (DECL_CONSTRUCTOR_P (node) && ! DECL_CONSTRUCTOR_P (function))
|
|| (DECL_DESTRUCTOR_P (node) && ! DECL_DESTRUCTOR_P (function)))
|
|| (DECL_DESTRUCTOR_P (node) && ! DECL_DESTRUCTOR_P (function)))
|
continue;
|
continue;
|
|
|
/* The arguments must match as well. */
|
/* The arguments must match as well. */
|
for (node_args = DECL_ARGUMENTS (node), func_args = DECL_ARGUMENTS (function);
|
for (node_args = DECL_ARGUMENTS (node), func_args = DECL_ARGUMENTS (function);
|
node_args && func_args;
|
node_args && func_args;
|
node_args = TREE_CHAIN (node_args), func_args = TREE_CHAIN (func_args))
|
node_args = TREE_CHAIN (node_args), func_args = TREE_CHAIN (func_args))
|
if (TREE_TYPE (node_args) != TREE_TYPE (func_args))
|
if (TREE_TYPE (node_args) != TREE_TYPE (func_args))
|
break;
|
break;
|
|
|
if (node_args || func_args)
|
if (node_args || func_args)
|
{
|
{
|
/* We can ignore an extraneous __in_chrg arguments in the node.
|
/* We can ignore an extraneous __in_chrg arguments in the node.
|
GCC generated destructors, for example, will have this. */
|
GCC generated destructors, for example, will have this. */
|
if ((node_args == NULL_TREE
|
if ((node_args == NULL_TREE
|
|| func_args != NULL_TREE)
|
|| func_args != NULL_TREE)
|
&& strcmp (IDENTIFIER_POINTER (DECL_NAME (node)), "__in_chrg") != 0)
|
&& strcmp (IDENTIFIER_POINTER (DECL_NAME (node)), "__in_chrg") != 0)
|
continue;
|
continue;
|
}
|
}
|
|
|
symbian_add_attribute (function, attr);
|
symbian_add_attribute (function, attr);
|
|
|
/* Propagate the attribute to any function thunks as well. */
|
/* Propagate the attribute to any function thunks as well. */
|
for (thunk = DECL_THUNKS (function); thunk; thunk = TREE_CHAIN (thunk))
|
for (thunk = DECL_THUNKS (function); thunk; thunk = TREE_CHAIN (thunk))
|
if (TREE_CODE (thunk) == FUNCTION_DECL)
|
if (TREE_CODE (thunk) == FUNCTION_DECL)
|
symbian_add_attribute (thunk, attr);
|
symbian_add_attribute (thunk, attr);
|
}
|
}
|
}
|
}
|
|
|
if (TREE_CODE (node) == FUNCTION_DECL && DECL_VIRTUAL_P (node))
|
if (TREE_CODE (node) == FUNCTION_DECL && DECL_VIRTUAL_P (node))
|
{
|
{
|
/* Propagate the attribute to any thunks of this function. */
|
/* Propagate the attribute to any thunks of this function. */
|
for (thunk = DECL_THUNKS (node); thunk; thunk = TREE_CHAIN (thunk))
|
for (thunk = DECL_THUNKS (node); thunk; thunk = TREE_CHAIN (thunk))
|
if (TREE_CODE (thunk) == FUNCTION_DECL)
|
if (TREE_CODE (thunk) == FUNCTION_DECL)
|
symbian_add_attribute (thunk, attr);
|
symbian_add_attribute (thunk, attr);
|
}
|
}
|
|
|
/* Report error if symbol is not accessible at global scope. */
|
/* Report error if symbol is not accessible at global scope. */
|
if (!TREE_PUBLIC (node)
|
if (!TREE_PUBLIC (node)
|
&& ( TREE_CODE (node) == VAR_DECL
|
&& ( TREE_CODE (node) == VAR_DECL
|
|| TREE_CODE (node) == FUNCTION_DECL))
|
|| TREE_CODE (node) == FUNCTION_DECL))
|
{
|
{
|
error ("external linkage required for symbol %q+D because of %qs attribute",
|
error ("external linkage required for symbol %q+D because of %qs attribute",
|
node, IDENTIFIER_POINTER (name));
|
node, IDENTIFIER_POINTER (name));
|
*no_add_attrs = true;
|
*no_add_attrs = true;
|
}
|
}
|
|
|
#if SYMBIAN_DEBUG
|
#if SYMBIAN_DEBUG
|
print_node_brief (stderr, "mark node", node, 0);
|
print_node_brief (stderr, "mark node", node, 0);
|
fprintf (stderr, " as %s\n", attr);
|
fprintf (stderr, " as %s\n", attr);
|
#endif
|
#endif
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* This code implements a specification for exporting the vtable and rtti of
|
/* This code implements a specification for exporting the vtable and rtti of
|
classes that have members with the dllexport or dllexport attributes.
|
classes that have members with the dllexport or dllexport attributes.
|
This specification is defined here:
|
This specification is defined here:
|
|
|
http://www.armdevzone.com/EABI/exported_class.txt
|
http://www.armdevzone.com/EABI/exported_class.txt
|
|
|
Basically it says that a class's vtable and rtti should be exported if
|
Basically it says that a class's vtable and rtti should be exported if
|
the following rules apply:
|
the following rules apply:
|
|
|
- If it has any non-inline non-pure virtual functions,
|
- If it has any non-inline non-pure virtual functions,
|
at least one of these need to be declared dllimport
|
at least one of these need to be declared dllimport
|
OR any of the constructors is declared dllimport.
|
OR any of the constructors is declared dllimport.
|
|
|
AND
|
AND
|
|
|
- The class has an inline constructor/destructor and
|
- The class has an inline constructor/destructor and
|
a key-function (placement of vtable uniquely defined) that
|
a key-function (placement of vtable uniquely defined) that
|
is defined in this translation unit.
|
is defined in this translation unit.
|
|
|
The specification also says that for classes which will have their
|
The specification also says that for classes which will have their
|
vtables and rtti exported that their base class(es) might also need a
|
vtables and rtti exported that their base class(es) might also need a
|
similar exporting if:
|
similar exporting if:
|
|
|
- Every base class needs to have its vtable & rtti exported
|
- Every base class needs to have its vtable & rtti exported
|
as well, if the following the conditions hold true:
|
as well, if the following the conditions hold true:
|
+ The base class has a non-inline declared non-pure virtual function
|
+ The base class has a non-inline declared non-pure virtual function
|
+ The base class is polymorphic (has or inherits any virtual functions)
|
+ The base class is polymorphic (has or inherits any virtual functions)
|
or the base class has any virtual base classes. */
|
or the base class has any virtual base classes. */
|
|
|
/* Decide if a base class of a class should
|
/* Decide if a base class of a class should
|
also have its vtable and rtti exported. */
|
also have its vtable and rtti exported. */
|
|
|
static void
|
static void
|
symbian_possibly_export_base_class (tree base_class)
|
symbian_possibly_export_base_class (tree base_class)
|
{
|
{
|
VEC(tree,gc) *method_vec;
|
VEC(tree,gc) *method_vec;
|
int len;
|
int len;
|
|
|
if (! (TYPE_CONTAINS_VPTR_P (base_class)))
|
if (! (TYPE_CONTAINS_VPTR_P (base_class)))
|
return;
|
return;
|
|
|
method_vec = CLASSTYPE_METHOD_VEC (base_class);
|
method_vec = CLASSTYPE_METHOD_VEC (base_class);
|
len = method_vec ? VEC_length (tree, method_vec) : 0;
|
len = method_vec ? VEC_length (tree, method_vec) : 0;
|
|
|
for (;len --;)
|
for (;len --;)
|
{
|
{
|
tree member = VEC_index (tree, method_vec, len);
|
tree member = VEC_index (tree, method_vec, len);
|
|
|
if (! member)
|
if (! member)
|
continue;
|
continue;
|
|
|
for (member = OVL_CURRENT (member); member; member = OVL_NEXT (member))
|
for (member = OVL_CURRENT (member); member; member = OVL_NEXT (member))
|
{
|
{
|
if (TREE_CODE (member) != FUNCTION_DECL)
|
if (TREE_CODE (member) != FUNCTION_DECL)
|
continue;
|
continue;
|
|
|
if (DECL_CONSTRUCTOR_P (member) || DECL_DESTRUCTOR_P (member))
|
if (DECL_CONSTRUCTOR_P (member) || DECL_DESTRUCTOR_P (member))
|
continue;
|
continue;
|
|
|
if (! DECL_VIRTUAL_P (member))
|
if (! DECL_VIRTUAL_P (member))
|
continue;
|
continue;
|
|
|
if (DECL_PURE_VIRTUAL_P (member))
|
if (DECL_PURE_VIRTUAL_P (member))
|
continue;
|
continue;
|
|
|
if (DECL_INLINE (member))
|
if (DECL_INLINE (member))
|
continue;
|
continue;
|
|
|
break;
|
break;
|
}
|
}
|
|
|
if (member)
|
if (member)
|
break;
|
break;
|
}
|
}
|
|
|
if (len < 0)
|
if (len < 0)
|
return;
|
return;
|
|
|
/* FIXME: According to the spec this base class should be exported, but
|
/* FIXME: According to the spec this base class should be exported, but
|
a) how do we do this ? and
|
a) how do we do this ? and
|
b) it does not appear to be necessary for compliance with the Symbian
|
b) it does not appear to be necessary for compliance with the Symbian
|
OS which so far is the only consumer of this code. */
|
OS which so far is the only consumer of this code. */
|
#if SYMBIAN_DEBUG
|
#if SYMBIAN_DEBUG
|
print_node_brief (stderr, "", base_class, 0);
|
print_node_brief (stderr, "", base_class, 0);
|
fprintf (stderr, " EXPORTed [base class of exported class]\n");
|
fprintf (stderr, " EXPORTed [base class of exported class]\n");
|
#endif
|
#endif
|
}
|
}
|
|
|
/* Decide if a class needs its vtable and rtti exporting. */
|
/* Decide if a class needs its vtable and rtti exporting. */
|
|
|
static bool
|
static bool
|
symbian_export_vtable_and_rtti_p (tree ctype)
|
symbian_export_vtable_and_rtti_p (tree ctype)
|
{
|
{
|
bool inline_ctor_dtor;
|
bool inline_ctor_dtor;
|
bool dllimport_ctor_dtor;
|
bool dllimport_ctor_dtor;
|
bool dllimport_member;
|
bool dllimport_member;
|
tree binfo, base_binfo;
|
tree binfo, base_binfo;
|
VEC(tree,gc) *method_vec;
|
VEC(tree,gc) *method_vec;
|
tree key;
|
tree key;
|
int i;
|
int i;
|
int len;
|
int len;
|
|
|
/* Make sure that we are examining a class... */
|
/* Make sure that we are examining a class... */
|
if (TREE_CODE (ctype) != RECORD_TYPE)
|
if (TREE_CODE (ctype) != RECORD_TYPE)
|
{
|
{
|
#if SYMBIAN_DEBUG
|
#if SYMBIAN_DEBUG
|
print_node_brief (stderr, "", ctype, 0);
|
print_node_brief (stderr, "", ctype, 0);
|
fprintf (stderr, " does NOT need to be EXPORTed [not a class]\n");
|
fprintf (stderr, " does NOT need to be EXPORTed [not a class]\n");
|
#endif
|
#endif
|
return false;
|
return false;
|
}
|
}
|
|
|
/* If the class does not have a key function it
|
/* If the class does not have a key function it
|
does not need to have its vtable exported. */
|
does not need to have its vtable exported. */
|
if ((key = CLASSTYPE_KEY_METHOD (ctype)) == NULL_TREE)
|
if ((key = CLASSTYPE_KEY_METHOD (ctype)) == NULL_TREE)
|
{
|
{
|
#if SYMBIAN_DEBUG
|
#if SYMBIAN_DEBUG
|
print_node_brief (stderr, "", ctype, 0);
|
print_node_brief (stderr, "", ctype, 0);
|
fprintf (stderr, " does NOT need to be EXPORTed [no key function]\n");
|
fprintf (stderr, " does NOT need to be EXPORTed [no key function]\n");
|
#endif
|
#endif
|
return false;
|
return false;
|
}
|
}
|
|
|
/* If the key fn has not been defined
|
/* If the key fn has not been defined
|
then the class should not be exported. */
|
then the class should not be exported. */
|
if (! TREE_ASM_WRITTEN (key))
|
if (! TREE_ASM_WRITTEN (key))
|
{
|
{
|
#if SYMBIAN_DEBUG
|
#if SYMBIAN_DEBUG
|
print_node_brief (stderr, "", ctype, 0);
|
print_node_brief (stderr, "", ctype, 0);
|
fprintf (stderr, " does NOT need to be EXPORTed [key function not defined]\n");
|
fprintf (stderr, " does NOT need to be EXPORTed [key function not defined]\n");
|
#endif
|
#endif
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Check the class's member functions. */
|
/* Check the class's member functions. */
|
inline_ctor_dtor = false;
|
inline_ctor_dtor = false;
|
dllimport_ctor_dtor = false;
|
dllimport_ctor_dtor = false;
|
dllimport_member = false;
|
dllimport_member = false;
|
|
|
method_vec = CLASSTYPE_METHOD_VEC (ctype);
|
method_vec = CLASSTYPE_METHOD_VEC (ctype);
|
len = method_vec ? VEC_length (tree, method_vec) : 0;
|
len = method_vec ? VEC_length (tree, method_vec) : 0;
|
|
|
for (;len --;)
|
for (;len --;)
|
{
|
{
|
tree member = VEC_index (tree, method_vec, len);
|
tree member = VEC_index (tree, method_vec, len);
|
|
|
if (! member)
|
if (! member)
|
continue;
|
continue;
|
|
|
for (member = OVL_CURRENT (member); member; member = OVL_NEXT (member))
|
for (member = OVL_CURRENT (member); member; member = OVL_NEXT (member))
|
{
|
{
|
if (TREE_CODE (member) != FUNCTION_DECL)
|
if (TREE_CODE (member) != FUNCTION_DECL)
|
continue;
|
continue;
|
|
|
if (DECL_CONSTRUCTOR_P (member) || DECL_DESTRUCTOR_P (member))
|
if (DECL_CONSTRUCTOR_P (member) || DECL_DESTRUCTOR_P (member))
|
{
|
{
|
if (DECL_INLINE (member)
|
if (DECL_INLINE (member)
|
/* Ignore C++ backend created inline ctors/dtors. */
|
/* Ignore C++ backend created inline ctors/dtors. */
|
&& ( DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (member)
|
&& ( DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (member)
|
|| DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (member)))
|
|| DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (member)))
|
inline_ctor_dtor = true;
|
inline_ctor_dtor = true;
|
|
|
if (lookup_attribute ("dllimport", DECL_ATTRIBUTES (member)))
|
if (lookup_attribute ("dllimport", DECL_ATTRIBUTES (member)))
|
dllimport_ctor_dtor = true;
|
dllimport_ctor_dtor = true;
|
}
|
}
|
else
|
else
|
{
|
{
|
if (DECL_PURE_VIRTUAL_P (member))
|
if (DECL_PURE_VIRTUAL_P (member))
|
continue;
|
continue;
|
|
|
if (! DECL_VIRTUAL_P (member))
|
if (! DECL_VIRTUAL_P (member))
|
continue;
|
continue;
|
|
|
if (DECL_INLINE (member))
|
if (DECL_INLINE (member))
|
continue;
|
continue;
|
|
|
if (lookup_attribute ("dllimport", DECL_ATTRIBUTES (member)))
|
if (lookup_attribute ("dllimport", DECL_ATTRIBUTES (member)))
|
dllimport_member = true;
|
dllimport_member = true;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
if (! dllimport_member && ! dllimport_ctor_dtor)
|
if (! dllimport_member && ! dllimport_ctor_dtor)
|
{
|
{
|
#if SYMBIAN_DEBUG
|
#if SYMBIAN_DEBUG
|
print_node_brief (stderr, "", ctype, 0);
|
print_node_brief (stderr, "", ctype, 0);
|
fprintf (stderr,
|
fprintf (stderr,
|
" does NOT need to be EXPORTed [no non-pure virtuals or ctors/dtors with dllimport]\n");
|
" does NOT need to be EXPORTed [no non-pure virtuals or ctors/dtors with dllimport]\n");
|
#endif
|
#endif
|
return false;
|
return false;
|
}
|
}
|
|
|
if (! inline_ctor_dtor)
|
if (! inline_ctor_dtor)
|
{
|
{
|
#if SYMBIAN_DEBUG
|
#if SYMBIAN_DEBUG
|
print_node_brief (stderr, "", ctype, 0);
|
print_node_brief (stderr, "", ctype, 0);
|
fprintf (stderr,
|
fprintf (stderr,
|
" does NOT need to be EXPORTed [no inline ctor/dtor]\n");
|
" does NOT need to be EXPORTed [no inline ctor/dtor]\n");
|
#endif
|
#endif
|
return false;
|
return false;
|
}
|
}
|
|
|
#if SYMBIAN_DEBUG
|
#if SYMBIAN_DEBUG
|
print_node_brief (stderr, "", ctype, 0);
|
print_node_brief (stderr, "", ctype, 0);
|
fprintf (stderr, " DOES need to be EXPORTed\n");
|
fprintf (stderr, " DOES need to be EXPORTed\n");
|
#endif
|
#endif
|
|
|
/* Now we must check and possibly export the base classes. */
|
/* Now we must check and possibly export the base classes. */
|
for (i = 0, binfo = TYPE_BINFO (ctype);
|
for (i = 0, binfo = TYPE_BINFO (ctype);
|
BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
|
BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
|
symbian_possibly_export_base_class (BINFO_TYPE (base_binfo));
|
symbian_possibly_export_base_class (BINFO_TYPE (base_binfo));
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Add the named attribute to a class and its vtable and rtti. */
|
/* Add the named attribute to a class and its vtable and rtti. */
|
|
|
static void
|
static void
|
symbian_add_attribute_to_class_vtable_and_rtti (tree ctype, const char *attr_name)
|
symbian_add_attribute_to_class_vtable_and_rtti (tree ctype, const char *attr_name)
|
{
|
{
|
symbian_add_attribute (ctype, attr_name);
|
symbian_add_attribute (ctype, attr_name);
|
|
|
/* If the vtable exists then they need annotating as well. */
|
/* If the vtable exists then they need annotating as well. */
|
if (CLASSTYPE_VTABLES (ctype))
|
if (CLASSTYPE_VTABLES (ctype))
|
/* XXX - Do we need to annotate any vtables other than the primary ? */
|
/* XXX - Do we need to annotate any vtables other than the primary ? */
|
symbian_add_attribute (CLASSTYPE_VTABLES (ctype), attr_name);
|
symbian_add_attribute (CLASSTYPE_VTABLES (ctype), attr_name);
|
|
|
/* If the rtti exists then it needs annotating as well. */
|
/* If the rtti exists then it needs annotating as well. */
|
if (TYPE_MAIN_VARIANT (ctype)
|
if (TYPE_MAIN_VARIANT (ctype)
|
&& CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (ctype)))
|
&& CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (ctype)))
|
symbian_add_attribute (CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (ctype)),
|
symbian_add_attribute (CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (ctype)),
|
attr_name);
|
attr_name);
|
}
|
}
|
|
|
/* Decide if a class needs to have an attribute because
|
/* Decide if a class needs to have an attribute because
|
one of its member functions has the attribute. */
|
one of its member functions has the attribute. */
|
|
|
static bool
|
static bool
|
symbian_class_needs_attribute_p (tree ctype, const char *attribute_name)
|
symbian_class_needs_attribute_p (tree ctype, const char *attribute_name)
|
{
|
{
|
VEC(tree,gc) *method_vec;
|
VEC(tree,gc) *method_vec;
|
|
|
method_vec = CLASSTYPE_METHOD_VEC (ctype);
|
method_vec = CLASSTYPE_METHOD_VEC (ctype);
|
|
|
/* If the key function has the attribute then the class needs it too. */
|
/* If the key function has the attribute then the class needs it too. */
|
if (TYPE_POLYMORPHIC_P (ctype)
|
if (TYPE_POLYMORPHIC_P (ctype)
|
&& method_vec
|
&& method_vec
|
&& lookup_attribute (attribute_name,
|
&& lookup_attribute (attribute_name,
|
DECL_ATTRIBUTES (VEC_index (tree, method_vec, 0))))
|
DECL_ATTRIBUTES (VEC_index (tree, method_vec, 0))))
|
return true;
|
return true;
|
|
|
/* Check the class's member functions. */
|
/* Check the class's member functions. */
|
if (TREE_CODE (ctype) == RECORD_TYPE)
|
if (TREE_CODE (ctype) == RECORD_TYPE)
|
{
|
{
|
unsigned int len;
|
unsigned int len;
|
|
|
len = method_vec ? VEC_length (tree, method_vec) : 0;
|
len = method_vec ? VEC_length (tree, method_vec) : 0;
|
|
|
for (;len --;)
|
for (;len --;)
|
{
|
{
|
tree member = VEC_index (tree, method_vec, len);
|
tree member = VEC_index (tree, method_vec, len);
|
|
|
if (! member)
|
if (! member)
|
continue;
|
continue;
|
|
|
for (member = OVL_CURRENT (member);
|
for (member = OVL_CURRENT (member);
|
member;
|
member;
|
member = OVL_NEXT (member))
|
member = OVL_NEXT (member))
|
{
|
{
|
if (TREE_CODE (member) != FUNCTION_DECL)
|
if (TREE_CODE (member) != FUNCTION_DECL)
|
continue;
|
continue;
|
|
|
if (DECL_PURE_VIRTUAL_P (member))
|
if (DECL_PURE_VIRTUAL_P (member))
|
continue;
|
continue;
|
|
|
if (! DECL_VIRTUAL_P (member))
|
if (! DECL_VIRTUAL_P (member))
|
continue;
|
continue;
|
|
|
if (lookup_attribute (attribute_name, DECL_ATTRIBUTES (member)))
|
if (lookup_attribute (attribute_name, DECL_ATTRIBUTES (member)))
|
{
|
{
|
#if SYMBIAN_DEBUG
|
#if SYMBIAN_DEBUG
|
print_node_brief (stderr, "", ctype, 0);
|
print_node_brief (stderr, "", ctype, 0);
|
fprintf (stderr, " inherits %s because", attribute_name);
|
fprintf (stderr, " inherits %s because", attribute_name);
|
print_node_brief (stderr, "", member, 0);
|
print_node_brief (stderr, "", member, 0);
|
fprintf (stderr, " has it.\n");
|
fprintf (stderr, " has it.\n");
|
#endif
|
#endif
|
return true;
|
return true;
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
#if SYMBIAN_DEBUG
|
#if SYMBIAN_DEBUG
|
print_node_brief (stderr, "", ctype, 0);
|
print_node_brief (stderr, "", ctype, 0);
|
fprintf (stderr, " does not inherit %s\n", attribute_name);
|
fprintf (stderr, " does not inherit %s\n", attribute_name);
|
#endif
|
#endif
|
return false;
|
return false;
|
}
|
}
|
|
|
int
|
int
|
symbian_import_export_class (tree ctype, int import_export)
|
symbian_import_export_class (tree ctype, int import_export)
|
{
|
{
|
const char *attr_name = NULL;
|
const char *attr_name = NULL;
|
|
|
/* If we are exporting the class but it does not have the dllexport
|
/* If we are exporting the class but it does not have the dllexport
|
attribute then we may need to add it. Similarly imported classes
|
attribute then we may need to add it. Similarly imported classes
|
may need the dllimport attribute. */
|
may need the dllimport attribute. */
|
switch (import_export)
|
switch (import_export)
|
{
|
{
|
case 1: attr_name = "dllexport"; break;
|
case 1: attr_name = "dllexport"; break;
|
case -1: attr_name = "dllimport"; break;
|
case -1: attr_name = "dllimport"; break;
|
default: break;
|
default: break;
|
}
|
}
|
|
|
if (attr_name
|
if (attr_name
|
&& ! lookup_attribute (attr_name, TYPE_ATTRIBUTES (ctype)))
|
&& ! lookup_attribute (attr_name, TYPE_ATTRIBUTES (ctype)))
|
{
|
{
|
if (symbian_class_needs_attribute_p (ctype, attr_name))
|
if (symbian_class_needs_attribute_p (ctype, attr_name))
|
symbian_add_attribute_to_class_vtable_and_rtti (ctype, attr_name);
|
symbian_add_attribute_to_class_vtable_and_rtti (ctype, attr_name);
|
|
|
/* Classes can be forced to export their
|
/* Classes can be forced to export their
|
vtable and rtti under certain conditions. */
|
vtable and rtti under certain conditions. */
|
if (symbian_export_vtable_and_rtti_p (ctype))
|
if (symbian_export_vtable_and_rtti_p (ctype))
|
{
|
{
|
symbian_add_attribute_to_class_vtable_and_rtti (ctype, "dllexport");
|
symbian_add_attribute_to_class_vtable_and_rtti (ctype, "dllexport");
|
|
|
/* Make sure that the class and its vtable are exported. */
|
/* Make sure that the class and its vtable are exported. */
|
import_export = 1;
|
import_export = 1;
|
|
|
if (CLASSTYPE_VTABLES (ctype))
|
if (CLASSTYPE_VTABLES (ctype))
|
DECL_EXTERNAL (CLASSTYPE_VTABLES (ctype)) = 1;
|
DECL_EXTERNAL (CLASSTYPE_VTABLES (ctype)) = 1;
|
|
|
/* Check to make sure that if the class has a key method that
|
/* Check to make sure that if the class has a key method that
|
it is now on the list of keyed classes. That way its vtable
|
it is now on the list of keyed classes. That way its vtable
|
will be emitted. */
|
will be emitted. */
|
if (CLASSTYPE_KEY_METHOD (ctype))
|
if (CLASSTYPE_KEY_METHOD (ctype))
|
{
|
{
|
tree class;
|
tree class;
|
|
|
for (class = keyed_classes; class; class = TREE_CHAIN (class))
|
for (class = keyed_classes; class; class = TREE_CHAIN (class))
|
if (class == ctype)
|
if (class == ctype)
|
break;
|
break;
|
|
|
if (class == NULL_TREE)
|
if (class == NULL_TREE)
|
{
|
{
|
#if SYMBIAN_DEBUG
|
#if SYMBIAN_DEBUG
|
print_node_brief (stderr, "Add node", ctype, 0);
|
print_node_brief (stderr, "Add node", ctype, 0);
|
fprintf (stderr, " to the keyed classes list\n");
|
fprintf (stderr, " to the keyed classes list\n");
|
#endif
|
#endif
|
keyed_classes = tree_cons (NULL_TREE, ctype, keyed_classes);
|
keyed_classes = tree_cons (NULL_TREE, ctype, keyed_classes);
|
}
|
}
|
}
|
}
|
|
|
/* Make sure that the typeinfo will be emitted as well. */
|
/* Make sure that the typeinfo will be emitted as well. */
|
if (CLASS_TYPE_P (ctype))
|
if (CLASS_TYPE_P (ctype))
|
TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (ctype)))) = 1;
|
TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (ctype)))) = 1;
|
}
|
}
|
}
|
}
|
|
|
return import_export;
|
return import_export;
|
}
|
}
|
|
|
/* Dummy definition of this array for cc1 building purposes. */
|
/* Dummy definition of this array for cc1 building purposes. */
|
tree cp_global_trees[CPTI_MAX] __attribute__((weak));
|
tree cp_global_trees[CPTI_MAX] __attribute__((weak));
|
|
|
#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
|
#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
|
|
|
/* Dummy version of this G++ function for building cc1. */
|
/* Dummy version of this G++ function for building cc1. */
|
void lang_check_failed (const char *, int, const char *) __attribute__((weak));
|
void lang_check_failed (const char *, int, const char *) __attribute__((weak));
|
|
|
void
|
void
|
lang_check_failed (const char *file, int line, const char *function)
|
lang_check_failed (const char *file, int line, const char *function)
|
{
|
{
|
internal_error ("lang_* check: failed in %s, at %s:%d",
|
internal_error ("lang_* check: failed in %s, at %s:%d",
|
function, trim_filename (file), line);
|
function, trim_filename (file), line);
|
}
|
}
|
#endif /* ENABLE_TREE_CHECKING */
|
#endif /* ENABLE_TREE_CHECKING */
|
|
|
