Subversion Repositories openrisc

/* Routines for GCC for a Symbian OS targeted SH backend.

   Copyright (C) 2004, 2005, 2007 Free Software Foundation, Inc.

   Contributed by RedHat.

   Most of this code is stolen from i386/winnt.c.

   This file is part of GCC.

   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 Software Foundation; either version 3, or (at your

   option) any later version.

   GCC is distributed in the hope that it will be useful, but WITHOUT

   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY

   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public

   License for more details.

   You should have received a copy of the GNU General Public License

   along with GCC; see the file COPYING3.  If not see

   <http://www.gnu.org/licenses/>.  */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "rtl.h"

#include "output.h"

#include "flags.h"

#include "tree.h"

#include "expr.h"

#include "tm_p.h"

#include "cp/cp-tree.h" /* We need access to the OVL_... macros.  */

#include "toplev.h"

/* Select the level of debugging information to display.

   1 for informative messages about decisions to add attributes

   2 for verbose information about what is being done.  */

#define SYMBIAN_DEBUG 0

/* #define SYMBIAN_DEBUG 1 */

/* #define SYMBIAN_DEBUG 2 */

/* A unique character to encode declspec encoded objects.  */

#define SH_SYMBIAN_FLAG_CHAR "$"

/* Unique strings to prefix exported and imported objects.  */

#define DLL_IMPORT_PREFIX SH_SYMBIAN_FLAG_CHAR "i."

#define DLL_EXPORT_PREFIX SH_SYMBIAN_FLAG_CHAR "e."

/* Return the type that we should use to determine if DECL is

   imported or exported.  */

static tree

sh_symbian_associated_type (tree decl)

{

  tree t = NULL_TREE;

  if (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)

  /* Methods now inherit their dllimport/dllexport attributes correctly

     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

     exported class.  */

    return t;

  /* Otherwise we can just take the DECL_CONTEXT as normal.  */

  if (DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl)))

    t = DECL_CONTEXT (decl);

  return t;

}

/* Return nonzero if DECL is a dllexport'd object.  */

bool

sh_symbian_dllexport_p (tree decl)

{

  tree exp;

  if (   TREE_CODE (decl) != VAR_DECL

      && TREE_CODE (decl) != FUNCTION_DECL)

    return false;

  exp = lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl));

  /* Class members get the dllexport status of their class.  */

  if (exp == NULL)

    {

      tree class = sh_symbian_associated_type (decl);

      if (class)

        exp = lookup_attribute ("dllexport", TYPE_ATTRIBUTES (class));

    }

#if SYMBIAN_DEBUG

  if (exp)

    {

      print_node_brief (stderr, "dllexport:", decl, 0);

      fprintf (stderr, "\n");

    }

  else

#if SYMBIAN_DEBUG < 2

    if (TREE_CODE (decl) != FUNCTION_DECL)

#endif

    {

      print_node_brief (stderr, "no dllexport:", decl, 0);

      fprintf (stderr, "\n");

    }

#endif

  return exp ? true : false;

}

/* Return nonzero if DECL is a dllimport'd object.  */

static bool

sh_symbian_dllimport_p (tree decl)

{

  tree imp;

  if (   TREE_CODE (decl) != VAR_DECL

      && TREE_CODE (decl) != FUNCTION_DECL)

    return false;

  imp = lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl));

  if (imp)

    return true;

  /* Class members get the dllimport status of their class.  */

  imp = sh_symbian_associated_type (decl);

  if (! imp)

    return false;

  imp = lookup_attribute ("dllimport", TYPE_ATTRIBUTES (imp));

  if (!imp)

    return false;

  /* Don't mark defined functions as dllimport.  If the definition itself

     was marked with dllimport, then sh_symbian_handle_dll_attribute reports

     an error. This handles the case when the definition overrides an

     earlier declaration.  */

  if (TREE_CODE (decl) ==  FUNCTION_DECL

      && DECL_INITIAL (decl)

      && !DECL_INLINE (decl))

    {

      /* Don't warn about artificial methods.  */

      if (!DECL_ARTIFICIAL (decl))

        warning (OPT_Wattributes, "function %q+D is defined after prior "

                 "declaration as dllimport: attribute ignored",

                 decl);

      return false;

    }

  /* We ignore the dllimport attribute for inline member functions.

     This differs from MSVC behavior which treats it like GNUC

     'extern inline' extension.   */

  else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_INLINE (decl))

    {

      if (extra_warnings)

        warning (OPT_Wattributes, "inline function %q+D is declared as "

                 "dllimport: attribute ignored",

                 decl);

      return false;

    }

  /*  Don't allow definitions of static data members in dllimport

      class.  Just ignore the attribute for vtable data.  */

  else if (TREE_CODE (decl) == VAR_DECL

           && TREE_STATIC (decl)

           && TREE_PUBLIC (decl)

           && !DECL_EXTERNAL (decl))

    {

      if (!DECL_VIRTUAL_P (decl))

        error ("definition of static data member %q+D of dllimport'd class",

               decl);

      return false;

    }

  /* Since we can't treat a pointer to a dllimport'd symbol as a

     constant address, we turn off the attribute on C++ virtual

     methods to allow creation of vtables using thunks.  Don't mark

     artificial methods either (in sh_symbian_associated_type, only

     COMDAT artificial method get import status from class context).  */

  else if (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE

           && (DECL_VIRTUAL_P (decl) || DECL_ARTIFICIAL (decl)))

    return false;

  return true;

}

/* Return nonzero if SYMBOL is marked as being dllexport'd.  */

bool

sh_symbian_dllexport_name_p (const char *symbol)

{

  return strncmp (DLL_EXPORT_PREFIX, symbol,

                  strlen (DLL_EXPORT_PREFIX)) == 0;

}

/* Return nonzero if SYMBOL is marked as being dllimport'd.  */

bool

sh_symbian_dllimport_name_p (const char *symbol)

{

  return strncmp (DLL_IMPORT_PREFIX, symbol,

                  strlen (DLL_IMPORT_PREFIX)) == 0;

}

/* Mark a DECL as being dllexport'd.

   Note that we override the previous setting (e.g.: dllimport).  */

static void

sh_symbian_mark_dllexport (tree decl)

{

  const char *oldname;

  char *newname;

  rtx rtlname;

  tree idp;

  rtlname = XEXP (DECL_RTL (decl), 0);

  if (GET_CODE (rtlname) == MEM)

    rtlname = XEXP (rtlname, 0);

  gcc_assert (GET_CODE (rtlname) == SYMBOL_REF);

  oldname = XSTR (rtlname, 0);

  if (sh_symbian_dllimport_name_p (oldname))

    {

     /* Remove DLL_IMPORT_PREFIX.

        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

        corresponding definition to be marked as dllexport.  The prototypes

        are in headers used everywhere and the definition is in a translation

        unit which has included the header in order to ensure argument

        correctness.  */

      oldname += strlen (DLL_IMPORT_PREFIX);

      DECL_DLLIMPORT_P (decl) = 0;

    }

  else if (sh_symbian_dllexport_name_p (oldname))

    return; /* Already done.  */

  newname = alloca (strlen (DLL_EXPORT_PREFIX) + strlen (oldname) + 1);

  sprintf (newname, "%s%s", DLL_EXPORT_PREFIX, oldname);

  /* We pass newname through get_identifier to ensure it has a unique

     address.  RTL processing can sometimes peek inside the symbol ref

     and compare the string's addresses to see if two symbols are

     identical.  */

  idp = get_identifier (newname);

  XEXP (DECL_RTL (decl), 0) =

    gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (idp));

}

/* Mark a DECL as being dllimport'd.  */

static void

sh_symbian_mark_dllimport (tree decl)

{

  const char *oldname;

  char *newname;

  tree idp;

  rtx rtlname;

  rtx newrtl;

  rtlname = XEXP (DECL_RTL (decl), 0);

  if (GET_CODE (rtlname) == MEM)

    rtlname = XEXP (rtlname, 0);

  gcc_assert (GET_CODE (rtlname) == SYMBOL_REF);

  oldname = XSTR (rtlname, 0);

  if (sh_symbian_dllexport_name_p (oldname))

    {

      error ("%qs declared as both exported to and imported from a DLL",

             IDENTIFIER_POINTER (DECL_NAME (decl)));

    }

  else if (sh_symbian_dllimport_name_p (oldname))

    {

      /* Already done, but do a sanity check to prevent assembler errors.  */

      if (!DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl))

        error ("failure in redeclaration of %q+D: dllimport'd symbol lacks external linkage",

               decl);

    }

  else

    {

      newname = alloca (strlen (DLL_IMPORT_PREFIX) + strlen (oldname) + 1);

      sprintf (newname, "%s%s", DLL_IMPORT_PREFIX, oldname);

      /* We pass newname through get_identifier to ensure it has a unique

         address.  RTL processing can sometimes peek inside the symbol ref

         and compare the string's addresses to see if two symbols are

         identical.  */

      idp = get_identifier (newname);

      newrtl = gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (idp));

      XEXP (DECL_RTL (decl), 0) = newrtl;

    }

}

void

sh_symbian_encode_section_info (tree decl, rtx rtl, int first)

{

  default_encode_section_info (decl, rtl, first);

  /* Mark the decl so we can tell from the rtl whether

     the object is dllexport'd or dllimport'd.  */

  if (sh_symbian_dllexport_p (decl))

    sh_symbian_mark_dllexport (decl);

  else if (sh_symbian_dllimport_p (decl))

    sh_symbian_mark_dllimport (decl);

  /* It might be that DECL has already been marked as dllimport, but a

     subsequent definition nullified that.  The attribute is gone but

     DECL_RTL still has (DLL_IMPORT_PREFIX) prefixed. We need to remove

     that. Ditto for the DECL_DLLIMPORT_P flag.  */

  else if (  (TREE_CODE (decl) == FUNCTION_DECL

           || TREE_CODE (decl) == VAR_DECL)

           && DECL_RTL (decl) != NULL_RTX

           && GET_CODE (DECL_RTL (decl)) == MEM

           && GET_CODE (XEXP (DECL_RTL (decl), 0)) == MEM

           && GET_CODE (XEXP (XEXP (DECL_RTL (decl), 0), 0)) == SYMBOL_REF

           && 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);

      /* Remove DLL_IMPORT_PREFIX.  */

      tree idp = get_identifier (oldname + strlen (DLL_IMPORT_PREFIX));

      rtx newrtl = gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (idp));

      warning (0, "%s %q+D %s after being referenced with dllimport linkage",

               TREE_CODE (decl) == VAR_DECL ? "variable" : "function",

               decl, (DECL_INITIAL (decl) || !DECL_EXTERNAL (decl))

               ? "defined locally" : "redeclared without dllimport attribute");

      XEXP (DECL_RTL (decl), 0) = newrtl;

      DECL_DLLIMPORT_P (decl) = 0;

    }

}

/* Return the length of a function name prefix

    that starts with the character 'c'.  */

static int

sh_symbian_get_strip_length (int c)

{

  /* XXX Assumes strlen (DLL_EXPORT_PREFIX) == strlen (DLL_IMPORT_PREFIX).  */

  return (c == SH_SYMBIAN_FLAG_CHAR[0]) ? strlen (DLL_EXPORT_PREFIX) : 0;

}

/* Return a pointer to a function's name with any

   and all prefix encodings stripped from it.  */

const char *

sh_symbian_strip_name_encoding (const char *name)

{

  int skip;

  while ((skip = sh_symbian_get_strip_length (*name)))

    name += skip;

  return name;

}

/* 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.  */

static void

symbian_add_attribute (tree node, const char *attr_name)

{

  tree attrs;

  tree attr;

  attrs = DECL_P (node) ? DECL_ATTRIBUTES (node) : TYPE_ATTRIBUTES (node);

  if (lookup_attribute (attr_name, attrs) != NULL_TREE)

    return;

  attr = get_identifier (attr_name);

  if (DECL_P (node))

    DECL_ATTRIBUTES (node) = tree_cons (attr, NULL_TREE, attrs);

  else

    TYPE_ATTRIBUTES (node) = tree_cons (attr, NULL_TREE, attrs);

#if SYMBIAN_DEBUG

  fprintf (stderr, "propogate %s attribute", attr_name);

  print_node_brief (stderr, " to", node, 0);

  fprintf (stderr, "\n");

#endif

}

/* Handle a "dllimport" or "dllexport" attribute;

   arguments as in struct attribute_spec.handler.  */

tree

sh_symbian_handle_dll_attribute (tree *pnode, tree name, tree args,

                                 int flags, bool *no_add_attrs)

{

  tree thunk;

  tree node = *pnode;

  const char *attr = IDENTIFIER_POINTER (name);

  /* These attributes may apply to structure and union types being

     created, but otherwise should pass to the declaration involved.  */

  if (!DECL_P (node))

    {

      if (flags & ((int) ATTR_FLAG_DECL_NEXT

                   | (int) ATTR_FLAG_FUNCTION_NEXT

                   | (int) ATTR_FLAG_ARRAY_NEXT))

        {

          warning (OPT_Wattributes, "%qs attribute ignored", attr);

          *no_add_attrs = true;

          return tree_cons (name, args, NULL_TREE);

        }

      if (TREE_CODE (node) != RECORD_TYPE && TREE_CODE (node) != UNION_TYPE)

        {

          warning (OPT_Wattributes, "%qs attribute ignored", attr);

          *no_add_attrs = true;

        }

      return NULL_TREE;

    }

  /* Report error on dllimport ambiguities

     seen now before they cause any damage.  */

  else if (is_attribute_p ("dllimport", name))

    {

      if (TREE_CODE (node) == VAR_DECL)

        {

          if (DECL_INITIAL (node))

            {

              error ("variable %q+D definition is marked dllimport",

                     node);

              *no_add_attrs = true;

            }

          /* `extern' needn't be specified with dllimport.

             Specify `extern' now and hope for the best.  Sigh.  */

          DECL_EXTERNAL (node) = 1;

          /* Also, implicitly give dllimport'd variables declared within

             a function global scope, unless declared static.  */

          if (current_function_decl != NULL_TREE && ! TREE_STATIC (node))

            TREE_PUBLIC (node) = 1;

        }

    }

  /* If the node is an overloaded constructor or destructor, then we must

     make sure that the attribute is propagated along the overload chain,

     as it is these overloaded functions which will be emitted, rather than

     the user declared constructor itself.  */

  if (TREE_CODE (TREE_TYPE (node)) == METHOD_TYPE

      && (DECL_CONSTRUCTOR_P (node) || DECL_DESTRUCTOR_P (node)))

    {

      tree overload;

      for (overload = OVL_CHAIN (node); overload; overload = OVL_CHAIN (overload))

        {

          tree node_args;

          tree func_args;

          tree function = OVL_CURRENT (overload);

          if (! function

              || ! DECL_P (function)

              || (DECL_CONSTRUCTOR_P (node) && ! DECL_CONSTRUCTOR_P (function))

              || (DECL_DESTRUCTOR_P (node)  && ! DECL_DESTRUCTOR_P (function)))

            continue;

          /* The arguments must match as well.  */

          for (node_args = DECL_ARGUMENTS (node), func_args = DECL_ARGUMENTS (function);

               node_args && func_args;

               node_args = TREE_CHAIN (node_args), func_args = TREE_CHAIN (func_args))

            if (TREE_TYPE (node_args) != TREE_TYPE (func_args))

              break;

          if (node_args || func_args)

            {

              /* We can ignore an extraneous __in_chrg arguments in the node.

                 GCC generated destructors, for example, will have this.  */

              if ((node_args == NULL_TREE

                   || func_args != NULL_TREE)

                  && strcmp (IDENTIFIER_POINTER (DECL_NAME (node)), "__in_chrg") != 0)

                continue;

            }

          symbian_add_attribute (function, attr);

          /* Propagate the attribute to any function thunks as well.  */

          for (thunk = DECL_THUNKS (function); thunk; thunk = TREE_CHAIN (thunk))

            if (TREE_CODE (thunk) == FUNCTION_DECL)

              symbian_add_attribute (thunk, attr);

        }

    }

  if (TREE_CODE (node) == FUNCTION_DECL && DECL_VIRTUAL_P (node))

    {

      /* Propagate the attribute to any thunks of this function.  */

      for (thunk = DECL_THUNKS (node); thunk; thunk = TREE_CHAIN (thunk))

        if (TREE_CODE (thunk) == FUNCTION_DECL)

          symbian_add_attribute (thunk, attr);

    }

  /*  Report error if symbol is not accessible at global scope.  */

  if (!TREE_PUBLIC (node)

      && (   TREE_CODE (node) == VAR_DECL

          || TREE_CODE (node) == FUNCTION_DECL))

    {

      error ("external linkage required for symbol %q+D because of %qs attribute",

             node, IDENTIFIER_POINTER (name));

      *no_add_attrs = true;

    }

#if SYMBIAN_DEBUG

  print_node_brief (stderr, "mark node", node, 0);

  fprintf (stderr, " as %s\n", attr);

#endif

  return NULL_TREE;

}

/* This code implements a specification for exporting the vtable and rtti of

   classes that have members with the dllexport or dllexport attributes.

   This specification is defined here:

     http://www.armdevzone.com/EABI/exported_class.txt

   Basically it says that a class's vtable and rtti should be exported if

   the following rules apply:

   - If it has any non-inline non-pure virtual functions,

     at least one of these need to be declared dllimport

     OR any of the constructors is declared dllimport.

   AND

   - The class has an inline constructor/destructor and

     a key-function (placement of vtable uniquely defined) that

     is defined in this translation unit.

   The specification also says that for classes which will have their

   vtables and rtti exported that their base class(es) might also need a

   similar exporting if:

   - Every base class needs to have its vtable & rtti exported

     as well, if the following the conditions hold true:

     + The base class has a non-inline declared non-pure virtual function

     + The base class is polymorphic (has or inherits any virtual functions)

       or the base class has any virtual base classes.  */

/* Decide if a base class of a class should

   also have its vtable and rtti exported.  */

static void

symbian_possibly_export_base_class (tree base_class)

{

  VEC(tree,gc) *method_vec;

  int len;

  if (! (TYPE_CONTAINS_VPTR_P (base_class)))

    return;

  method_vec = CLASSTYPE_METHOD_VEC (base_class);

  len = method_vec ? VEC_length (tree, method_vec) : 0;

  for (;len --;)

    {

      tree member = VEC_index (tree, method_vec, len);

      if (! member)

        continue;

      for (member = OVL_CURRENT (member); member; member = OVL_NEXT (member))

        {

          if (TREE_CODE (member) != FUNCTION_DECL)

            continue;

          if (DECL_CONSTRUCTOR_P (member) || DECL_DESTRUCTOR_P (member))

            continue;

          if (! DECL_VIRTUAL_P (member))

            continue;

          if (DECL_PURE_VIRTUAL_P (member))

            continue;

          if (DECL_INLINE (member))

            continue;

          break;

        }

      if (member)

        break;

    }

  if (len < 0)

    return;

  /* FIXME: According to the spec this base class should be exported, but

     a) how do we do this ? and

     b) it does not appear to be necessary for compliance with the Symbian

        OS which so far is the only consumer of this code.  */

#if SYMBIAN_DEBUG

  print_node_brief (stderr, "", base_class, 0);

  fprintf (stderr, " EXPORTed [base class of exported class]\n");

#endif

}

/* Decide if a class needs its vtable and rtti exporting.  */

static bool

symbian_export_vtable_and_rtti_p (tree ctype)

{

  bool inline_ctor_dtor;

  bool dllimport_ctor_dtor;

  bool dllimport_member;

  tree binfo, base_binfo;

  VEC(tree,gc) *method_vec;

  tree key;

  int i;

  int len;

  /* Make sure that we are examining a class...  */

  if (TREE_CODE (ctype) != RECORD_TYPE)

    {

#if SYMBIAN_DEBUG

      print_node_brief (stderr, "", ctype, 0);

      fprintf (stderr, " does NOT need to be EXPORTed [not a class]\n");

#endif

      return false;

    }

  /* If the class does not have a key function it

     does not need to have its vtable exported.  */

  if ((key = CLASSTYPE_KEY_METHOD (ctype)) == NULL_TREE)

    {

#if SYMBIAN_DEBUG

      print_node_brief (stderr, "", ctype, 0);

      fprintf (stderr, " does NOT need to be EXPORTed [no key function]\n");

#endif

      return false;

    }

  /* If the key fn has not been defined

     then the class should not be exported.  */

  if (! TREE_ASM_WRITTEN (key))

    {

#if SYMBIAN_DEBUG

      print_node_brief (stderr, "", ctype, 0);

      fprintf (stderr, " does NOT need to be EXPORTed [key function not defined]\n");

#endif

      return false;

    }

  /* Check the class's member functions.  */

  inline_ctor_dtor = false;

  dllimport_ctor_dtor = false;

  dllimport_member = false;

  method_vec = CLASSTYPE_METHOD_VEC (ctype);

  len = method_vec ? VEC_length (tree, method_vec) : 0;

  for (;len --;)

    {

      tree member = VEC_index (tree, method_vec, len);

      if (! member)

        continue;

      for (member = OVL_CURRENT (member); member; member = OVL_NEXT (member))

        {

          if (TREE_CODE (member) != FUNCTION_DECL)

            continue;

          if (DECL_CONSTRUCTOR_P (member) || DECL_DESTRUCTOR_P (member))

            {

              if (DECL_INLINE (member)

                  /* Ignore C++ backend created inline ctors/dtors.  */

                  && (   DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (member)

                      || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (member)))

                inline_ctor_dtor = true;

              if (lookup_attribute ("dllimport", DECL_ATTRIBUTES (member)))

                dllimport_ctor_dtor = true;

            }

          else

            {

              if (DECL_PURE_VIRTUAL_P (member))

                continue;

              if (! DECL_VIRTUAL_P (member))

                continue;

              if (DECL_INLINE (member))

                continue;

              if (lookup_attribute ("dllimport", DECL_ATTRIBUTES (member)))

                dllimport_member = true;

            }

        }

    }