Subversion Repositories openrisc

/* VMS specific, C compiler specific functions.
   Copyright (C) 2011
   Free Software Foundation, Inc.
   Contributed by Tristan Gingold (gingold@adacore.com).
 
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 "cpplib.h"
#include "tree.h"
#include "c-family/c-pragma.h"
#include "c-family/c-common.h"
#include "toplev.h"
#include "ggc.h"
#include "tm_p.h"
#include "incpath.h"
#include "diagnostic.h"
 
/* '#pragma __nostandard' is simply ignored.  */
 
static void
vms_pragma_nostandard (cpp_reader *pfile ATTRIBUTE_UNUSED)
{
  tree x;
 
  if (pragma_lex (&x) != CPP_EOF)
    warning (OPT_Wpragmas, "junk at end of #pragma __nostandard");
}
 
/* '#pragma __standard' is simply ignored.  */
 
static void
vms_pragma_standard (cpp_reader *pfile ATTRIBUTE_UNUSED)
{
  tree x;
 
  if (pragma_lex (&x) != CPP_EOF)
    warning (OPT_Wpragmas, "junk at end of #pragma __standard");
}
 
/* Saved member alignment.  */
static int saved_member_alignment;
 
/* Handle '#pragma member_alignment'.  */
 
static void
vms_pragma_member_alignment (cpp_reader *pfile ATTRIBUTE_UNUSED)
{
  tree x;
  int tok;
  const char *arg;
 
  tok = pragma_lex (&x);
 
  if (tok == CPP_EOF)
    {
      /* Disable packing.  */
      maximum_field_alignment = initial_max_fld_align;
      return;
    }
  if (tok != CPP_NAME)
    {
      warning (OPT_Wpragmas, "malformed '#pragma member_alignment', ignoring");
      return;
    }
 
  arg = IDENTIFIER_POINTER (x);
  /* Accept '__' prefix.  */
  if (arg[0] == '_' && arg[1] == '_')
    arg += 2;
 
  if (strcmp (arg, "save") == 0)
    saved_member_alignment = maximum_field_alignment;
  else if (strcmp (arg, "restore") == 0)
    maximum_field_alignment = saved_member_alignment;
  else
    {
      error ("unknown '#pragma member_alignment' name %s", arg);
      return;
    }
  if (pragma_lex (&x) != CPP_EOF)
    {
      error ("malformed '#pragma member_alignment'");
      return;
    }
}
 
/* Handle '#pragma nomember_alignment'.  */
 
static void
vms_pragma_nomember_alignment (cpp_reader *pfile ATTRIBUTE_UNUSED)
{
  tree x;
  int tok;
 
  tok = pragma_lex (&x);
  if (tok == CPP_NAME)
    {
      const char *arg = IDENTIFIER_POINTER (x);
 
      /* Accept '__' prefix.  */
      if (arg[0] == '_' && arg[1] == '_')
        arg += 2;
 
      if (strcmp (arg, "word") == 0)
        maximum_field_alignment = 2 * BITS_PER_UNIT;
      else if (strcmp (arg, "longword") == 0)
        maximum_field_alignment = 4 * BITS_PER_UNIT;
      else if (strcmp (arg, "quadword") == 0)
        maximum_field_alignment = 8 * BITS_PER_UNIT;
      else
        {
          error ("unhandled alignment for '#pragma nomember_alignment'");
        }
 
      tok = pragma_lex (&x);
    }
  else
    {
      /* Enable packing.  */
      maximum_field_alignment = BITS_PER_UNIT;
    }
 
  if (tok != CPP_EOF)
    {
      error ("garbage at end of '#pragma nomember_alignment'");
      return;
    }
}
 
/* The 'extern model' for public data.  */
 
enum extern_model_kind
{
  /* Create one overlaid section per variable.  */
  extern_model_common_block,
 
  /* Like unix: multiple not-initialized declarations are allowed.  */
  extern_model_relaxed_refdef,
 
  /* Like -fno-common.  */
  extern_model_strict_refdef,
 
  /* Declarations creates symbols without storage.  */
  extern_model_globalvalue
};
 
/* Current and saved extern model.  */
static enum extern_model_kind current_extern_model;
static enum extern_model_kind saved_extern_model;
 
/* Partial handling of '#pragma extern_model'.  */
 
static void
vms_pragma_extern_model (cpp_reader *pfile ATTRIBUTE_UNUSED)
{
  tree x;
  int tok;
  const char *arg;
 
  tok = pragma_lex (&x);
 
  if (tok != CPP_NAME)
    {
      warning (OPT_Wpragmas, "malformed '#pragma extern_model', ignoring");
      return;
    }
 
  arg = IDENTIFIER_POINTER (x);
  /* Accept "__" prefix.  */
  if (arg[0] == '_' && arg[1] == '_')
    arg += 2;
 
  if (strcmp (arg, "save") == 0)
    saved_extern_model = current_extern_model;
  else if (strcmp (arg, "restore") == 0)
    current_extern_model = saved_extern_model;
  else if (strcmp (arg, "strict_refdef") == 0)
    current_extern_model = extern_model_strict_refdef;
  else if (strcmp (arg, "common_block") == 0)
    current_extern_model = extern_model_common_block;
  else if (strcmp (arg, "globalvalue") == 0)
    {
      sorry ("extern model globalvalue");
      return;
    }
  else
    {
      error ("unknown '#pragma extern_model' model '%s'", arg);
      return;
    }
#if 0
  if (pragma_lex (&x) != CPP_EOF)
    {
      permerror (input_location, "junk at end of '#pragma extern_model'");
      return;
    }
#endif
}
 
/* Ignore '#pragma message'.  */
 
static void
vms_pragma_message (cpp_reader *pfile ATTRIBUTE_UNUSED)
{
  /* Completly ignored.  */
#if 0
  pedwarn (input_location, OPT_Wpragmas,
           "vms '#pragma __message' is ignored");
#endif
}
 
/* Handle '#pragma __extern_prefix'  */
 
static GTY(()) tree saved_extern_prefix;
 
static void
vms_pragma_extern_prefix (cpp_reader * ARG_UNUSED (dummy))
{
  enum cpp_ttype tok;
  tree x;
 
  tok = pragma_lex (&x);
  if (tok == CPP_NAME)
    {
      const char *op = IDENTIFIER_POINTER (x);
 
      if (!strcmp (op, "__save"))
        saved_extern_prefix = pragma_extern_prefix;
      else if (!strcmp (op, "__restore"))
        pragma_extern_prefix = saved_extern_prefix;
      else
        warning (OPT_Wpragmas,
                 "malformed '#pragma __extern_prefix', ignoring");
      return;
    }
  else if (tok != CPP_STRING)
    {
      warning (OPT_Wpragmas,
               "malformed '#pragma __extern_prefix', ignoring");
    }
  else
    {
      /* Note that the length includes the null terminator.  */
      pragma_extern_prefix = (TREE_STRING_LENGTH (x) > 1 ? x : NULL);
    }
}
 
/* Add vms-specific pragma.  */
 
void
vms_c_register_pragma (void)
{
  c_register_pragma (NULL, "__nostandard", vms_pragma_nostandard);
  c_register_pragma (NULL, "nostandard", vms_pragma_nostandard);
  c_register_pragma (NULL, "__standard", vms_pragma_standard);
  c_register_pragma (NULL, "standard", vms_pragma_standard);
  c_register_pragma (NULL, "__member_alignment", vms_pragma_member_alignment);
  c_register_pragma (NULL, "member_alignment", vms_pragma_member_alignment);
  c_register_pragma (NULL, "__nomember_alignment",
                     vms_pragma_nomember_alignment);
  c_register_pragma (NULL, "nomember_alignment",
                     vms_pragma_nomember_alignment);
  c_register_pragma (NULL, "__extern_model", vms_pragma_extern_model);
  c_register_pragma (NULL, "extern_model", vms_pragma_extern_model);
  c_register_pragma (NULL, "__message", vms_pragma_message);
  c_register_pragma (NULL, "__extern_prefix", vms_pragma_extern_prefix);
}
 
/* Standard modules list.  */
static const char * const vms_std_modules[] = { "rtldef", "starlet_c", NULL };
 
/* Find include modules in the include path.  */
 
void
vms_c_register_includes (const char *sysroot,
                         const char *iprefix ATTRIBUTE_UNUSED, int stdinc)
{
  static const char dir_separator_str[] = { DIR_SEPARATOR, 0 };
  struct cpp_dir *dir;
 
  /* Add on standard include pathes.  */
  if (!stdinc)
    return;
 
  for (dir = get_added_cpp_dirs (SYSTEM); dir != NULL; dir = dir->next)
    {
      const char * const *lib;
      for (lib = vms_std_modules; *lib != NULL; lib++)
        {
          char *path;
          struct stat st;
 
          if (sysroot != NULL)
            path = concat (sysroot, dir->name, dir_separator_str, *lib, NULL);
          else
            path = concat (dir->name, dir_separator_str, *lib, NULL);
 
          if (stat (path, &st) == 0 && S_ISDIR (st.st_mode))
            {
              cpp_dir *p;
 
              p = XNEW (cpp_dir);
              p->next = NULL;
              p->name = path;
              p->sysp = 1;
              p->construct = 0;
              p->user_supplied_p = 0;
              add_cpp_dir_path (p, SYSTEM);
            }
          else
            free (path);
        }
    }
}