Home | History | Annotate | Line # | Download | only in gcc
diagnostic-spec.h revision 1.1 
      1 /* Language-independent APIs to enable/disable per-location warnings.
      2 
      3    Copyright (C) 2021-2022 Free Software Foundation, Inc.
      4    Contributed by Martin Sebor <msebor (at) redhat.com>
      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 #ifndef DIAGNOSTIC_SPEC_H_INCLUDED
     23 #define DIAGNOSTIC_SPEC_H_INCLUDED
     24 
     25 #include "hash-map.h"
     26 
     27 /* A "bitset" of warning groups.  */
     28 
     29 class nowarn_spec_t
     30 {
     31 public:
     32   enum
     33     {
     34      /* Middle end warnings about invalid accesses.  */
     35      NW_ACCESS = 1 << 0,
     36      /* Front end/lexical warnings.  */
     37      NW_LEXICAL = 1 << 1,
     38      /* Warnings about null pointers.  */
     39      NW_NONNULL = 1 << 2,
     40      /* Warnings about uninitialized reads.  */
     41      NW_UNINIT = 1 << 3,
     42      /* Warnings about arithmetic overflow.  */
     43      NW_VFLOW = 1 << 4,
     44      /* Warnings about dangling pointers.  */
     45      NW_DANGLING = 1 << 5,
     46      /* All other unclassified warnings.  */
     47      NW_OTHER = 1 << 6,
     48      /* All groups of warnings.  */
     49      NW_ALL = (NW_ACCESS | NW_LEXICAL | NW_NONNULL
     50 	       | NW_UNINIT | NW_VFLOW | NW_DANGLING | NW_OTHER)
     51    };
     52 
     53   nowarn_spec_t (): m_bits () { }
     54 
     55   nowarn_spec_t (opt_code);
     56 
     57   /* Return the raw bitset.  */
     58   operator unsigned() const
     59   {
     60     return m_bits;
     61   }
     62 
     63   /* Return true if the bitset is clear.  */
     64   bool operator!() const
     65   {
     66     return !m_bits;
     67   }
     68 
     69   /* Return the inverse of the bitset.  */
     70   nowarn_spec_t operator~() const
     71   {
     72     nowarn_spec_t res (*this);
     73     res.m_bits &= ~NW_ALL;
     74     return res;
     75   }
     76 
     77   /* Set *THIS to the bitwise OR of *THIS and RHS.  */
     78   nowarn_spec_t& operator|= (const nowarn_spec_t &rhs)
     79   {
     80     m_bits |= rhs.m_bits;
     81     return *this;
     82   }
     83 
     84   /* Set *THIS to the bitwise AND of *THIS and RHS.  */
     85   nowarn_spec_t& operator&= (const nowarn_spec_t &rhs)
     86   {
     87     m_bits &= rhs.m_bits;
     88     return *this;
     89   }
     90 
     91   /* Set *THIS to the bitwise exclusive OR of *THIS and RHS.  */
     92   nowarn_spec_t& operator^= (const nowarn_spec_t &rhs)
     93   {
     94     m_bits ^= rhs.m_bits;
     95     return *this;
     96   }
     97 
     98 private:
     99   /* Bitset of warning groups.  */
    100   unsigned m_bits;
    101 };
    102 
    103 /* Return the bitwise OR of LHS and RHS.  */
    104 
    105 inline nowarn_spec_t
    106 operator| (const nowarn_spec_t &lhs, const nowarn_spec_t &rhs)
    107 {
    108   return nowarn_spec_t (lhs) |= rhs;
    109 }
    110 
    111 /* Return the bitwise AND of LHS and RHS.  */
    112 
    113 inline nowarn_spec_t
    114 operator& (const nowarn_spec_t &lhs, const nowarn_spec_t &rhs)
    115 {
    116   return nowarn_spec_t (lhs) &= rhs;
    117 }
    118 
    119 /* Return true if LHS is equal RHS.  */
    120 
    121 inline bool
    122 operator== (const nowarn_spec_t &lhs, const nowarn_spec_t &rhs)
    123 {
    124   return static_cast<unsigned>(lhs) == static_cast<unsigned>(rhs);
    125 }
    126 
    127 /* Return true if LHS is not equal RHS.  */
    128 
    129 inline bool
    130 operator!= (const nowarn_spec_t &lhs, const nowarn_spec_t &rhs)
    131 {
    132   return !(lhs == rhs);
    133 }
    134 
    135 typedef hash_map<location_hash, nowarn_spec_t> nowarn_map_t;
    136 
    137 /* A mapping from a 'location_t' to the warning spec set for it.  */
    138 extern GTY(()) nowarn_map_t *nowarn_map;
    139 
    140 #endif // DIAGNOSTIC_SPEC_H_INCLUDED
    141