gcc/config/riscv/riscv-target-attr.cc

   1 /* Subroutines used for parsing target attribute for RISC-V.
   2    Copyright (C) 2023-2024 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 3, or (at your option)
   9 any later version.
  10
  11 GCC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 #define IN_TARGET_CODE 1
  21
  22 #define INCLUDE_MEMORY
  23 #define INCLUDE_STRING
  24 #include "config.h"
  25 #include "system.h"
  26 #include "coretypes.h"
  27 #include "target.h"
  28 #include "tree.h"
  29 #include "tm_p.h"
  30 #include "diagnostic.h"
  31 #include "opts.h"
  32 #include "riscv-subset.h"
  33
  34 namespace {
  35 class riscv_target_attr_parser
  36 {
  37 public:
  38   riscv_target_attr_parser (location_t loc)
  39     : m_found_arch_p (false)
  40     , m_found_tune_p (false)
  41     , m_found_cpu_p (false)
  42     , m_subset_list (nullptr)
  43     , m_loc (loc)
  44     , m_cpu_info (nullptr)
  45     , m_tune (nullptr)
  46   {
  47   }
  48
  49   bool handle_arch (const char *);
  50   bool handle_cpu (const char *);
  51   bool handle_tune (const char *);
  52
  53   void set_loc (location_t loc) {
  54     m_loc = loc;
  55   }
  56
  57   void update_settings (struct gcc_options *opts) const;
  58 private:
  59   const char *m_raw_attr_str;
  60   bool parse_arch (const char *);
  61
  62   bool m_found_arch_p;
  63   bool m_found_tune_p;
  64   bool m_found_cpu_p;
  65   riscv_subset_list *m_subset_list;
  66   location_t m_loc;
  67   const  riscv_cpu_info *m_cpu_info;
  68   const char *m_tune;
  69 };
  70 }
  71
  72 /* All the information needed to handle a target attribute.
  73    NAME is the name of the attribute.
  74    HANDLER is the function that takes the attribute string as an argument.  */
  75
  76 struct riscv_attribute_info
  77 {
  78   const char *name;
  79   bool (riscv_target_attr_parser::*handler) (const char *);
  80 };
  81
  82 /* The target attributes that we support.  */
  83
  84 static const struct riscv_attribute_info riscv_attributes[]
  85   = {{"arch", &riscv_target_attr_parser::handle_arch},
  86      {"cpu", &riscv_target_attr_parser::handle_cpu},
  87      {"tune", &riscv_target_attr_parser::handle_tune}};
  88
  89 bool
  90 riscv_target_attr_parser::parse_arch (const char *str)
  91 {
  92   if (m_subset_list)
  93     delete m_subset_list;
  94   /* Check if it's setting full arch string.  */
  95   if (strncmp ("rv", str, strlen ("rv")) == 0)
  96     {
  97       m_subset_list = riscv_subset_list::parse (str, location_t ());
  98
  99       if (m_subset_list == nullptr)
 100         goto fail;
 101
 102       return true;
 103     }
 104   else
 105     {
 106       /* Parsing the extension list like "+<ext>[,+<ext>]*".  */
 107       size_t len = strlen (str);
 108       std::unique_ptr<char[]> buf (new char[len]);
 109       char *str_to_check = buf.get ();
 110       strcpy (str_to_check, str);
 111       const char *token = strtok_r (str_to_check, ",", &str_to_check);
 112       m_subset_list = riscv_current_subset_list ()->clone ();
 113       m_subset_list->set_loc (m_loc);
 114       while (token)
 115         {
 116           if (token[0] != '+')
 117             {
 118               error_at (
 119                 m_loc,
 120                 "unexpected arch for %<target()%> attribute: must start "
 121                 "with + or rv");
 122               goto fail;
 123             }
 124           else
 125             {
 126               const char *result = m_subset_list->parse_single_ext (token + 1);
 127               /* Check parse_single_ext has consume all string.  */
 128               if (*result != '\0')
 129                 {
 130                   error_at (
 131                     m_loc,
 132                     "unexpected arch for %<target()%> attribute: bad "
 133                     "string found %<%s%>", token);
 134                   goto fail;
 135                 }
 136             }
 137           token = strtok_r (NULL, ",", &str_to_check);
 138         }
 139       return true;
 140     }
 141 fail:
 142   if (m_subset_list != nullptr)
 143     {
 144       delete m_subset_list;
 145       m_subset_list = nullptr;
 146     }
 147   return false;
 148 }
 149
 150 /* Handle the ARCH_STR argument to the arch= target attribute.  */
 151
 152 bool
 153 riscv_target_attr_parser::handle_arch (const char *str)
 154 {
 155   if (m_found_arch_p)
 156     error_at (m_loc, "%<target()%> attribute: arch appears more than once");
 157   m_found_arch_p = true;
 158   return parse_arch (str);
 159 }
 160
 161 /* Handle the CPU_STR argument to the cpu= target attribute.  */
 162
 163 bool
 164 riscv_target_attr_parser::handle_cpu (const char *str)
 165 {
 166   if (m_found_cpu_p)
 167     error_at (m_loc, "%<target()%> attribute: cpu appears more than once");
 168
 169   m_found_cpu_p = true;
 170   const riscv_cpu_info *cpu_info = riscv_find_cpu (str);
 171
 172   if (!cpu_info)
 173     {
 174       error_at (m_loc, "%<target()%> attribute: unknown CPU %qs", str);
 175       return false;
 176     }
 177
 178   if (m_subset_list == nullptr)
 179     {
 180       const char *arch_str = cpu_info->arch;
 181       m_subset_list = riscv_subset_list::parse (arch_str, m_loc);
 182       gcc_assert (m_subset_list);
 183     }
 184
 185   m_cpu_info = cpu_info;
 186   return true;
 187 }
 188
 189 /* Handle the TUNE_STR argument to the tune= target attribute.  */
 190
 191 bool
 192 riscv_target_attr_parser::handle_tune (const char *str)
 193 {
 194   if (m_found_tune_p)
 195     error_at (m_loc, "%<target()%> attribute: tune appears more than once");
 196   m_found_tune_p = true;
 197   const struct riscv_tune_info *tune = riscv_parse_tune (str, true);
 198
 199   if (tune == nullptr)
 200     {
 201       error_at (m_loc, "%<target()%> attribute: unknown TUNE %qs", str);
 202       return false;
 203     }
 204
 205   m_tune = tune->name;
 206
 207   return true;
 208 }
 209
 210 void
 211 riscv_target_attr_parser::update_settings (struct gcc_options *opts) const
 212 {
 213   if (m_subset_list)
 214     riscv_set_arch_by_subset_list (m_subset_list, opts);
 215
 216   if (m_cpu_info)
 217     opts->x_riscv_cpu_string = m_cpu_info->name;
 218
 219   if (m_tune)
 220     opts->x_riscv_tune_string = m_tune;
 221   else
 222     {
 223       if (m_cpu_info)
 224         opts->x_riscv_tune_string = m_cpu_info->tune;
 225     }
 226 }
 227
 228 /* Parse ARG_STR which contains the definition of one target attribute.
 229    Show appropriate errors if any or return true if the attribute is valid.  */
 230
 231 static bool
 232 riscv_process_one_target_attr (char *arg_str,
 233                                location_t loc,
 234                                riscv_target_attr_parser &attr_parser)
 235 {
 236   size_t len = strlen (arg_str);
 237
 238   if (len == 0)
 239     {
 240       error_at (loc, "malformed %<target()%> attribute");
 241       return false;
 242     }
 243
 244   std::unique_ptr<char[]> buf (new char[len]);
 245   char *str_to_check = buf.get();
 246   strcpy (str_to_check, arg_str);
 247
 248   char *arg = strchr (str_to_check, '=');
 249
 250   if (!arg)
 251     {
 252       error_at (
 253         loc,
 254         "attribute %<target(\"%s\")%> does not accept an argument",
 255         str_to_check);
 256       return false;
 257     }
 258
 259   arg[0] = '\0';
 260   ++arg;
 261   for (const auto &attr : riscv_attributes)
 262     {
 263       /* If the names don't match up, or the user has given an argument
 264          to an attribute that doesn't accept one, or didn't give an argument
 265          to an attribute that expects one, fail to match.  */
 266       if (strncmp (str_to_check, attr.name, strlen (attr.name)) != 0)
 267         continue;
 268
 269       return (&attr_parser->*attr.handler) (arg);
 270     }
 271   error_at (loc, "Got unknown attribute %<target(\"%s\")%>", str_to_check);
 272
 273   return false;
 274 }
 275
 276 /* Count how many times the character C appears in
 277    NULL-terminated string STR.  */
 278
 279 static unsigned int
 280 num_occurences_in_str (char c, char *str)
 281 {
 282   unsigned int res = 0;
 283   while (*str != '\0')
 284     {
 285       if (*str == c)
 286         res++;
 287
 288       str++;
 289     }
 290
 291   return res;
 292 }
 293
 294 /* Parse the tree in ARGS that contains the target attribute information
 295    and update the global target options space.  */
 296
 297 static bool
 298 riscv_process_target_attr (tree args, location_t loc, struct gcc_options *opts)
 299 {
 300   if (TREE_CODE (args) == TREE_LIST)
 301     {
 302       do
 303         {
 304           tree head = TREE_VALUE (args);
 305           if (head)
 306             {
 307               if (!riscv_process_target_attr (head, loc, opts))
 308                 return false;
 309             }
 310           args = TREE_CHAIN (args);
 311       } while (args);
 312
 313       return true;
 314     }
 315
 316   if (TREE_CODE (args) != STRING_CST)
 317     {
 318       error_at (loc, "attribute %<target%> argument not a string");
 319       return false;
 320     }
 321   size_t len = strlen (TREE_STRING_POINTER (args));
 322
 323   /* No need to emit warning or error on empty string here, generic code already
 324      handle this case.  */
 325   if (len == 0)
 326     {
 327       return false;
 328     }
 329
 330   std::unique_ptr<char[]> buf (new char[len]);
 331   char *str_to_check = buf.get ();
 332   strcpy (str_to_check, TREE_STRING_POINTER (args));
 333
 334   /* Used to catch empty spaces between commas i.e.
 335      attribute ((target ("attr1;;attr2"))).  */
 336   unsigned int num_commas = num_occurences_in_str (';', str_to_check);
 337
 338   /* Handle multiple target attributes separated by ','.  */
 339   char *token = strtok_r (str_to_check, ";", &str_to_check);
 340
 341   riscv_target_attr_parser attr_parser (loc);
 342   unsigned int num_attrs = 0;
 343   while (token)
 344     {
 345       num_attrs++;
 346       riscv_process_one_target_attr (token, loc, attr_parser);
 347       token = strtok_r (NULL, ";", &str_to_check);
 348     }
 349
 350   if (num_attrs != num_commas + 1)
 351     {
 352       error_at (loc, "malformed %<target(\"%s\")%> attribute",
 353                 TREE_STRING_POINTER (args));
 354       return false;
 355     }
 356
 357   /* Apply settings from target attribute.  */
 358   attr_parser.update_settings (opts);
 359
 360   return true;
 361 }
 362
 363 /* Implement TARGET_OPTION_VALID_ATTRIBUTE_P.  This is used to
 364    process attribute ((target ("..."))).  */
 365
 366 bool
 367 riscv_option_valid_attribute_p (tree fndecl, tree, tree args, int)
 368 {
 369   struct cl_target_option cur_target;
 370   bool ret;
 371   tree new_target;
 372   location_t loc = DECL_SOURCE_LOCATION (fndecl);
 373
 374   /* Save the current target options to restore at the end.  */
 375   cl_target_option_save (&cur_target, &global_options, &global_options_set);
 376
 377   ret = riscv_process_target_attr (args, loc, &global_options);
 378
 379   if (ret)
 380     {
 381       riscv_override_options_internal (&global_options);
 382       new_target
 383         = build_target_option_node (&global_options, &global_options_set);
 384     }
 385   else
 386     new_target = NULL;
 387
 388   if (fndecl && ret)
 389     {
 390       DECL_FUNCTION_SPECIFIC_TARGET (fndecl) = new_target;
 391     }
 392
 393   cl_target_option_restore (&global_options, &global_options_set, &cur_target);
 394   return ret;
 395 }