gcc/warning-control.cc

   1 /* Functions to enable and disable individual warnings on an expression
   2    and statement basis.
   3
   4    Copyright (C) 2021 Free Software Foundation, Inc.
   5
   6    This file is part of GCC.
   7
   8    GCC is free software; you can redistribute it and/or modify it under
   9    the terms of the GNU General Public License as published by the Free
  10    Software Foundation; either version 3, or (at your option) any later
  11    version.
  12
  13    GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14    WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16    for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with GCC; see the file COPYING3.  If not see
  20    <http://www.gnu.org/licenses/>.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "backend.h"
  26 #include "bitmap.h"
  27 #include "tree.h"
  28 #include "gimple.h"
  29 #include "cgraph.h"
  30 #include "hash-map.h"
  31 #include "diagnostic-spec.h"
  32
  33 /* Return the no-warning bit for EXPR.  */
  34
  35 static inline bool
  36 get_no_warning_bit (const_tree expr)
  37 {
  38   return expr->base.nowarning_flag;
  39 }
  40
  41 /* Return the no-warning bit for statement STMT.  */
  42
  43 static inline bool
  44 get_no_warning_bit (const gimple *stmt)
  45 {
  46   return stmt->no_warning;
  47 }
  48
  49 /* Set the no-warning bit for EXPR to VALUE.  */
  50
  51 static inline void
  52 set_no_warning_bit (tree expr, bool value)
  53 {
  54   expr->base.nowarning_flag = value;
  55 }
  56
  57 /* Set the no-warning bit for statement STMT to VALUE.  */
  58
  59 static inline void
  60 set_no_warning_bit (gimple *stmt, bool value)
  61 {
  62   stmt->no_warning = value;
  63 }
  64
  65 /* Return EXPR location or zero.  */
  66
  67 static inline key_type_t
  68 convert_to_key (const_tree expr)
  69 {
  70   if (DECL_P (expr))
  71     return DECL_SOURCE_LOCATION (expr);
  72   if (EXPR_P (expr))
  73     return EXPR_LOCATION (expr);
  74   return 0;
  75 }
  76
  77 /* Return STMT location (may be zero).  */
  78
  79 static inline key_type_t
  80 convert_to_key (const gimple *stmt)
  81 {
  82   return gimple_location (stmt);
  83 }
  84
  85 /* Return the no-warning bitmap for decl/expression EXPR.  */
  86
  87 static nowarn_spec_t *
  88 get_nowarn_spec (const_tree expr)
  89 {
  90   const key_type_t key = convert_to_key (expr);
  91
  92   if (!get_no_warning_bit (expr) || !key)
  93     return NULL;
  94
  95   return nowarn_map ? nowarn_map->get (key) : NULL;
  96 }
  97
  98 /* Return the no-warning bitmap for stateemt STMT.  */
  99
 100 static nowarn_spec_t *
 101 get_nowarn_spec (const gimple *stmt)
 102 {
 103   const key_type_t key = convert_to_key (stmt);
 104
 105   if (!get_no_warning_bit (stmt))
 106     return NULL;
 107
 108   return nowarn_map ? nowarn_map->get (key) : NULL;
 109 }
 110
 111 /* Return true if warning OPT is suppressed for decl/expression EXPR.
 112    By default tests the disposition for any warning.  */
 113
 114 bool
 115 warning_suppressed_p (const_tree expr, opt_code opt /* = all_warnings */)
 116 {
 117   const nowarn_spec_t *spec = get_nowarn_spec (expr);
 118
 119   if (!spec)
 120     return get_no_warning_bit (expr);
 121
 122   const nowarn_spec_t optspec (opt);
 123   bool dis = *spec & optspec;
 124   gcc_assert (get_no_warning_bit (expr) || !dis);
 125   return dis;
 126 }
 127
 128 /* Return true if warning OPT is suppressed for statement STMT.
 129    By default tests the disposition for any warning.  */
 130
 131 bool
 132 warning_suppressed_p (const gimple *stmt, opt_code opt /* = all_warnings */)
 133 {
 134   const nowarn_spec_t *spec = get_nowarn_spec (stmt);
 135
 136   if (!spec)
 137     /* Fall back on the single no-warning bit.  */
 138     return get_no_warning_bit (stmt);
 139
 140   const nowarn_spec_t optspec (opt);
 141   bool dis = *spec & optspec;
 142   gcc_assert (get_no_warning_bit (stmt) || !dis);
 143   return dis;
 144 }
 145
 146 /* Enable, or by default disable, a warning for the expression.
 147    The wildcard OPT of -1 controls all warnings.  */
 148
 149 void
 150 suppress_warning (tree expr, opt_code opt /* = all_warnings */,
 151                   bool supp /* = true */)
 152 {
 153   if (opt == no_warning)
 154     return;
 155
 156   const key_type_t key = convert_to_key (expr);
 157
 158   supp = suppress_warning_at (key, opt, supp) || supp;
 159   set_no_warning_bit (expr, supp);
 160 }
 161
 162 /* Enable, or by default disable, a warning for the statement STMT.
 163    The wildcard OPT of -1 controls all warnings.  */
 164
 165 void
 166 suppress_warning (gimple *stmt, opt_code opt /* = all_warnings */,
 167                   bool supp /* = true */)
 168 {
 169   if (opt == no_warning)
 170     return;
 171
 172   const key_type_t key = convert_to_key (stmt);
 173
 174   supp = suppress_warning_at (key, opt, supp) || supp;
 175   set_no_warning_bit (stmt, supp);
 176 }
 177
 178 /* Copy the warning disposition mapping between an expression and/or
 179    a statement.  */
 180
 181 template <class ToType, class FromType>
 182 void copy_warning (ToType to, FromType from)
 183 {
 184   const key_type_t to_key = convert_to_key (to);
 185
 186   if (nowarn_spec_t *from_map = get_nowarn_spec (from))
 187     {
 188       /* If there's an entry in the map the no-warning bit must be set.  */
 189       gcc_assert (get_no_warning_bit (from));
 190
 191       if (!nowarn_map)
 192         nowarn_map = xint_hash_map_t::create_ggc (32);
 193
 194       nowarn_map->put (to_key, *from_map);
 195       set_no_warning_bit (to, true);
 196     }
 197   else
 198     {
 199       if (nowarn_map)
 200         nowarn_map->remove (to_key);
 201
 202       /* The no-warning bit might be set even if there's no entry
 203          in the map.  */
 204       set_no_warning_bit (to, get_no_warning_bit (from));
 205     }
 206 }
 207
 208 /* Copy the warning disposition mapping from one expression to another.  */
 209
 210 void
 211 copy_warning (tree to, const_tree from)
 212 {
 213   copy_warning<tree, const_tree>(to, from);
 214 }
 215
 216 /* Copy the warning disposition mapping from a statement to an expression.  */
 217
 218 void
 219 copy_warning (tree to, const gimple *from)
 220 {
 221   copy_warning<tree, const gimple *>(to, from);
 222 }
 223
 224 /* Copy the warning disposition mapping from an expression to a statement.  */
 225
 226 void
 227 copy_warning (gimple *to, const_tree from)
 228 {
 229   copy_warning<gimple *, const_tree>(to, from);
 230 }
 231
 232 /* Copy the warning disposition mapping from one statement to another.  */
 233
 234 void
 235 copy_warning (gimple *to, const gimple *from)
 236 {
 237   copy_warning<gimple *, const gimple *>(to, from);
 238 }