gcc/config/mep/mep-pragma.c

   1 /* Definitions of Toshiba Media Processor
   2    Copyright (C) 2001-2015 Free Software Foundation, Inc.
   3    Contributed by Red Hat, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "tm.h"
  25 #include "hash-set.h"
  26 #include "machmode.h"
  27 #include "vec.h"
  28 #include "double-int.h"
  29 #include "input.h"
  30 #include "alias.h"
  31 #include "symtab.h"
  32 #include "wide-int.h"
  33 #include "inchash.h"
  34 #include "tree.h"
  35 #include "diagnostic-core.h"
  36 #include "c-family/c-pragma.h"
  37 #include "cpplib.h"
  38 #include "hard-reg-set.h"
  39 #include "output.h" /* for decode_reg_name */
  40 #include "mep-protos.h"
  41 #include "input.h"
  42 #include "function.h"
  43 #define MAX_RECOG_OPERANDS 10
  44 #include "reload.h"
  45 #include "target.h"
  46
  47 enum cw_which { CW_AVAILABLE, CW_CALL_SAVED };
  48
  49 /* This is normally provided by rtl.h but we can't include that file
  50    here.  It's safe to copy the definition here because we're only
  51    using it internally; the value isn't passed to functions outside
  52    this file.  */
  53 #ifndef INVALID_REGNUM
  54 #define INVALID_REGNUM                    (~(unsigned int) 0)
  55 #endif
  56
  57 static enum cpp_ttype
  58 mep_pragma_lex (tree *valp)
  59 {
  60   enum cpp_ttype t = pragma_lex (valp);
  61   if (t == CPP_EOF)
  62     t = CPP_PRAGMA_EOL;
  63   return t;
  64 }
  65
  66 static void
  67 mep_pragma_io_volatile (cpp_reader *reader ATTRIBUTE_UNUSED)
  68 {
  69   /* On off.  */
  70   tree val;
  71   enum cpp_ttype type;
  72   const char * str;
  73
  74   type = mep_pragma_lex (&val);
  75   if (type == CPP_NAME)
  76     {
  77       str = IDENTIFIER_POINTER (val);
  78
  79       type = mep_pragma_lex (&val);
  80       if (type != CPP_PRAGMA_EOL)
  81         warning (0, "junk at end of #pragma io_volatile");
  82
  83       if (strcmp (str, "on") == 0)
  84         {
  85           target_flags |= MASK_IO_VOLATILE;
  86           return;
  87         }
  88       if (strcmp (str, "off") == 0)
  89         {
  90           target_flags &= ~ MASK_IO_VOLATILE;
  91           return;
  92         }
  93     }
  94
  95   error ("#pragma io_volatile takes only on or off");
  96 }
  97
  98 static unsigned int
  99 parse_cr_reg (const char * str)
 100 {
 101   unsigned int regno;
 102
 103   regno = decode_reg_name (str);
 104   if (regno >= FIRST_PSEUDO_REGISTER)
 105     return INVALID_REGNUM;
 106
 107   /* Verify that the regno is in CR_REGS.  */
 108   if (! TEST_HARD_REG_BIT (reg_class_contents[CR_REGS], regno))
 109     return INVALID_REGNUM;
 110   return regno;
 111 }
 112
 113 static bool
 114 parse_cr_set (HARD_REG_SET * set)
 115 {
 116   tree val;
 117   enum cpp_ttype type;
 118   unsigned int last_regno = INVALID_REGNUM;
 119   bool do_range = false;
 120
 121   CLEAR_HARD_REG_SET (*set);
 122
 123   while ((type = mep_pragma_lex (&val)) != CPP_PRAGMA_EOL)
 124     {
 125       if (type == CPP_COMMA)
 126         {
 127           last_regno = INVALID_REGNUM;
 128           do_range = false;
 129         }
 130       else if (type == CPP_ELLIPSIS)
 131         {
 132           if (last_regno == INVALID_REGNUM)
 133             {
 134               error ("invalid coprocessor register range");
 135               return false;
 136             }
 137           do_range = true;
 138         }
 139       else if (type == CPP_NAME || type == CPP_STRING)
 140         {
 141           const char *str;
 142           unsigned int regno, i;
 143
 144           if (TREE_CODE (val) == IDENTIFIER_NODE)
 145             str = IDENTIFIER_POINTER (val);
 146           else if (TREE_CODE (val) == STRING_CST)
 147             str = TREE_STRING_POINTER (val);
 148           else
 149             gcc_unreachable ();
 150
 151           regno = parse_cr_reg (str);
 152           if (regno == INVALID_REGNUM)
 153             {
 154               error ("invalid coprocessor register %qE", val);
 155               return false;
 156             }
 157
 158           if (do_range)
 159             {
 160               if (last_regno > regno)
 161                 i = regno, regno = last_regno;
 162               else
 163                 i = last_regno;
 164               do_range = false;
 165             }
 166           else
 167             last_regno = i = regno;
 168
 169           while (i <= regno)
 170             {
 171               SET_HARD_REG_BIT (*set, i);
 172               i++;
 173             }
 174         }
 175       else
 176         {
 177           error ("malformed coprocessor register");
 178           return false;
 179         }
 180     }
 181   return true;
 182 }
 183
 184 static void
 185 mep_pragma_coprocessor_which (enum cw_which cw_which)
 186 {
 187   HARD_REG_SET set;
 188
 189   /* Process the balance of the pragma and turn it into a hard reg set.  */
 190   if (! parse_cr_set (&set))
 191     return;
 192
 193   /* Process the collected hard reg set.  */
 194   switch (cw_which)
 195     {
 196     case CW_AVAILABLE:
 197       {
 198         int i;
 199         for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
 200           if (TEST_HARD_REG_BIT (set, i))
 201             fixed_regs[i] = 0;
 202       }
 203       break;
 204
 205     case CW_CALL_SAVED:
 206       {
 207         int i;
 208         for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
 209           if (TEST_HARD_REG_BIT (set, i))
 210             fixed_regs[i] = call_used_regs[i] = 0;
 211       }
 212       break;
 213
 214     default:
 215       gcc_unreachable ();
 216     }
 217
 218   /* Fix up register class hierarchy.  */
 219   mep_save_register_info ();
 220   mep_reinit_regs ();
 221
 222   if (cfun == 0)
 223     {
 224       init_dummy_function_start ();
 225       init_caller_save ();
 226       expand_dummy_function_end ();
 227     }
 228   else
 229     {
 230       init_caller_save ();
 231     }
 232 }
 233
 234 static void
 235 mep_pragma_coprocessor_width (void)
 236 {
 237   tree val;
 238   enum cpp_ttype type;
 239   HOST_WIDE_INT i;
 240
 241   type = mep_pragma_lex (&val);
 242   switch (type)
 243     {
 244     case CPP_NUMBER:
 245       if (! tree_fits_uhwi_p (val))
 246         break;
 247       i = tree_to_uhwi (val);
 248       /* This pragma no longer has any effect.  */
 249 #if 0
 250       if (i == 32)
 251         target_flags &= ~MASK_64BIT_CR_REGS;
 252       else if (i == 64)
 253         target_flags |= MASK_64BIT_CR_REGS;
 254       else
 255         break;
 256       targetm.init_builtins ();
 257 #else
 258       if (i != 32 && i != 64)
 259         break;
 260 #endif
 261
 262       type = mep_pragma_lex (&val);
 263       if (type != CPP_PRAGMA_EOL)
 264         warning (0, "junk at end of #pragma GCC coprocessor width");
 265       return;
 266
 267     default:
 268       break;
 269     }
 270
 271   error ("#pragma GCC coprocessor width takes only 32 or 64");
 272 }
 273
 274 static void
 275 mep_pragma_coprocessor_subclass (void)
 276 {
 277   tree val;
 278   enum cpp_ttype type;
 279   HARD_REG_SET set;
 280   int class_letter;
 281   enum reg_class rclass;
 282
 283   type = mep_pragma_lex (&val);
 284   if (type != CPP_CHAR)
 285     goto syntax_error;
 286   class_letter = tree_to_uhwi (val);
 287   switch (class_letter)
 288     {
 289     case 'A':
 290       rclass = USER0_REGS;
 291       break;
 292     case 'B':
 293       rclass = USER1_REGS;
 294       break;
 295     case 'C':
 296       rclass = USER2_REGS;
 297       break;
 298     case 'D':
 299       rclass = USER3_REGS;
 300       break;
 301     default:
 302       error ("#pragma GCC coprocessor subclass letter must be in [ABCD]");
 303       return;
 304     }
 305   if (reg_class_size[rclass] > 0)
 306     {
 307       error ("#pragma GCC coprocessor subclass '%c' already defined",
 308              class_letter);
 309       return;
 310     }
 311
 312   type = mep_pragma_lex (&val);
 313   if (type != CPP_EQ)
 314     goto syntax_error;
 315
 316   if (! parse_cr_set (&set))
 317     return;
 318
 319   /* Fix up register class hierarchy.  */
 320   COPY_HARD_REG_SET (reg_class_contents[rclass], set);
 321   mep_init_regs ();
 322   return;
 323
 324  syntax_error:
 325   error ("malformed #pragma GCC coprocessor subclass");
 326 }
 327
 328 static void
 329 mep_pragma_disinterrupt (cpp_reader *reader ATTRIBUTE_UNUSED)
 330 {
 331   tree val;
 332   enum cpp_ttype type;
 333   int saw_one = 0;
 334
 335   for (;;)
 336     {
 337       type = mep_pragma_lex (&val);
 338       if (type == CPP_COMMA)
 339         continue;
 340       if (type != CPP_NAME)
 341         break;
 342       mep_note_pragma_disinterrupt (IDENTIFIER_POINTER (val));
 343       saw_one = 1;
 344     }
 345   if (!saw_one || type != CPP_PRAGMA_EOL)
 346     {
 347       error ("malformed #pragma disinterrupt");
 348       return;
 349     }
 350 }
 351
 352 static void
 353 mep_pragma_coprocessor (cpp_reader *reader ATTRIBUTE_UNUSED)
 354 {
 355   tree val;
 356   enum cpp_ttype type;
 357
 358   type = mep_pragma_lex (&val);
 359   if (type != CPP_NAME)
 360     {
 361       error ("malformed #pragma GCC coprocessor");
 362       return;
 363     }
 364
 365   if (!TARGET_COP)
 366     error ("coprocessor not enabled");
 367
 368   if (strcmp (IDENTIFIER_POINTER (val), "available") == 0)
 369     mep_pragma_coprocessor_which (CW_AVAILABLE);
 370   else if (strcmp (IDENTIFIER_POINTER (val), "call_saved") == 0)
 371     mep_pragma_coprocessor_which (CW_CALL_SAVED);
 372   else if (strcmp (IDENTIFIER_POINTER (val), "width") == 0)
 373     mep_pragma_coprocessor_width ();
 374   else if (strcmp (IDENTIFIER_POINTER (val), "subclass") == 0)
 375     mep_pragma_coprocessor_subclass ();
 376   else
 377     error ("unknown #pragma GCC coprocessor %E", val);
 378 }
 379
 380 static void
 381 mep_pragma_call (cpp_reader *reader ATTRIBUTE_UNUSED)
 382 {
 383   tree val;
 384   enum cpp_ttype type;
 385   int saw_one = 0;
 386
 387   for (;;)
 388     {
 389       type = mep_pragma_lex (&val);
 390       if (type == CPP_COMMA)
 391         continue;
 392       if (type != CPP_NAME)
 393         break;
 394       mep_note_pragma_call (IDENTIFIER_POINTER (val));
 395       saw_one = 1;
 396     }
 397   if (!saw_one || type != CPP_PRAGMA_EOL)
 398     {
 399       error ("malformed #pragma call");
 400       return;
 401     }
 402 }
 403
 404 void
 405 mep_register_pragmas (void)
 406 {
 407   c_register_pragma ("custom", "io_volatile", mep_pragma_io_volatile);
 408   c_register_pragma ("GCC", "coprocessor", mep_pragma_coprocessor);
 409   c_register_pragma (0, "disinterrupt", mep_pragma_disinterrupt);
 410   c_register_pragma (0, "call", mep_pragma_call);
 411 }