GCC Middle and Back End API Reference
qualifier_set Struct Reference

#include <tree.h>

Public Types

enum class  merge_error : unsigned char { disjoint_address_spaces , atomic_mismatch }
enum class  join_error : unsigned char { double_addr_space }

Public Member Functions

 qualifier_set ()=default
constexpr qualifier_set (cv_qualifier cv_quals)
constexpr qualifier_set (cv_qualifier cv_quals, addr_space_t as)
constexpr void add (cv_qualifier qual)
constexpr void remove (cv_qualifier qual)
constexpr void set_as (addr_space_t as)
WARN_UNUSED_RESULT constexpr qualifier_set with (cv_qualifier qual) const
WARN_UNUSED_RESULT constexpr qualifier_set without (cv_qualifier qual) const
WARN_UNUSED_RESULT constexpr qualifier_set with_as (addr_space_t as) const
constexpr cv_qualifier cv_quals () const
constexpr addr_space_t addr_space () const
WARN_UNUSED_RESULT constexpr cv_qualifier intersect (cv_qualifier other_cv) const
constexpr bool has (cv_qualifier other_cv) const
WARN_UNUSED_RESULT constexpr qualifier_set symmetric_difference (cv_qualifier qual) const
bool superset_of (qualifier_set subset, bool nop_only=false) const
gcc::expected< qualifier_set, merge_error > merge (qualifier_set other, bool strict_addr_space=false) const
gcc::expected< qualifier_set, join_error > join (qualifier_set other) const
constexpr std::pair< cv_qualifier, addr_space_t > split () const
constexpr bool nonempty_p () const
constexpr operator bool () const
void debug () const

Private Attributes

cv_qualifier m_cv_quals
addr_space_t m_addr_space

Friends

constexpr bool operator== (const qualifier_set &a, const qualifier_set &b)
constexpr bool operator!= (const qualifier_set &a, const qualifier_set &b)

Detailed Description

A qualifier set is the aggregate of all qualifiers on a given type.  It
consists of the 'const', 'volatile', 'restrict', and 'atomic' qualification,
which are all either present or absent, and an address space qualifier,
which is always present (but possibly ADDR_SPACE_GENERIC).   

Member Enumeration Documentation

◆ join_error

enum class qualifier_set::join_error : unsigned char
strong
Enumerator
double_addr_space 

◆ merge_error

enum class qualifier_set::merge_error : unsigned char
strong
Enumerator
disjoint_address_spaces 
atomic_mismatch 

Constructor & Destructor Documentation

◆ qualifier_set() [1/3]

qualifier_set::qualifier_set ( )
default

◆ qualifier_set() [2/3]

qualifier_set::qualifier_set ( cv_qualifier cv_quals)
inlineconstexpr

◆ qualifier_set() [3/3]

qualifier_set::qualifier_set ( cv_qualifier cv_quals,
addr_space_t as )
inlineconstexpr

References cv_quals(), m_addr_space, and m_cv_quals.

Member Function Documentation

◆ add()

void qualifier_set::add ( cv_qualifier qual)
inlineconstexpr

References m_cv_quals.

Referenced by with().

◆ addr_space()

addr_space_t qualifier_set::addr_space ( ) const
inlineconstexpr

◆ cv_quals()

cv_qualifier qualifier_set::cv_quals ( ) const
inlineconstexpr

◆ debug()

DEBUG_FUNCTION void qualifier_set::debug ( ) const

◆ has()

bool qualifier_set::has ( cv_qualifier other_cv) const
inlineconstexpr

References intersect().

Referenced by merge(), and set_type_quals().

◆ intersect()

WARN_UNUSED_RESULT constexpr cv_qualifier qualifier_set::intersect ( cv_qualifier other_cv) const
inlineconstexpr

References cv_quals().

Referenced by has().

◆ join()

gcc::expected< qualifier_set, qualifier_set::join_error > qualifier_set::join ( qualifier_set other) const
Return a qualifier set that has all the qualifiers of THIS and OTHER.
Unlike 'merge', this operation operates purely syntactically; if THIS is
{q1_1, q1_2, ..., q1_i} and OTHER {q2_1, q2_2, ..., q2_j}, then returns the
qualifier set obtained by concatenating the sequences q1 and q2 without
duplicates, if such a qualifier set is valid.

Specifically, this implies that if THIS or OTHER both (syntactically)
contain an address space qualifier, and they're different, the operation
fails (even if one is subset of the other).

This operation may fail.  In that case, the error value returned provides
reasoning for the failure.

You'll need to include stdbackport/expected to use this.   

References addr_space(), ADDR_SPACE_GENERIC, ADDR_SPACE_GENERIC_P, cv_quals(), and qualifier_set().

◆ merge()

gcc::expected< qualifier_set, qualifier_set::merge_error > qualifier_set::merge ( qualifier_set other,
bool strict_addr_space = false ) const
Attempt to produce a qualifier_set that's a merge of qualifiers in THIS and
OTHER.  Such a qualifier set can be used instead of either THIS or OTHER
safely.  (i.e. if a type was qualified by either THIS or OTHER, it can be
qualified by their merge instead safely, possibly through a conversion)

This operation may fail.  In that case, the error value returned provides
reasoning for the failure.

If STRICT_ADDR_SPACE, then no address space mismatch is permitted.  This is
useful if merging below the top-level of pointers (i.e. in a case such as
'AS1 T**' vs 'AS2 T**').

You'll need to include stdbackport/expected to use this.   

References addr_space(), cv_quals(), has(), qualifier_set(), targetm, and TYPE_QUAL_ATOMIC.

◆ nonempty_p()

bool qualifier_set::nonempty_p ( ) const
inlineconstexpr

References qualifier_set().

Referenced by operator bool().

◆ operator bool()

qualifier_set::operator bool ( ) const
inlineexplicitconstexpr

References bool, and nonempty_p().

◆ remove()

void qualifier_set::remove ( cv_qualifier qual)
inlineconstexpr

References m_cv_quals.

Referenced by without().

◆ set_as()

void qualifier_set::set_as ( addr_space_t as)
inlineconstexpr

References m_addr_space.

Referenced by with_as().

◆ split()

std::pair< cv_qualifier, addr_space_t > qualifier_set::split ( ) const
inlineconstexpr

References addr_space(), and cv_quals().

Referenced by dequeue_and_dump().

◆ superset_of()

bool qualifier_set::superset_of ( qualifier_set other,
bool pointee = false ) const
Returns true if qualifiers in OTHER can be replaced with qualifiers in THIS
safely.

If !POINTEE, such a replacement is safe iff 'cv2 int *' can be converted
into 'cv1 int *' where cv1 are the qualifiers in THIS and cv2 the qualifiers
in OTHER.

Otherwise, such a replacement is safe iff 'cv2 int * const *' can be
converted into 'cv1 int * const *' with cv1 and cv2 as above.   

References addr_space(), cv_quals(), qualifier_set(), targetm, and TYPE_QUAL_ATOMIC.

◆ symmetric_difference()

WARN_UNUSED_RESULT constexpr qualifier_set qualifier_set::symmetric_difference ( cv_qualifier qual) const
inlineconstexpr

References addr_space(), and cv_quals().

Referenced by operator^(), and operator^().

◆ with()

WARN_UNUSED_RESULT constexpr qualifier_set qualifier_set::with ( cv_qualifier qual) const
inlineconstexpr

References add().

Referenced by operator|(), and operator|().

◆ with_as()

WARN_UNUSED_RESULT constexpr qualifier_set qualifier_set::with_as ( addr_space_t as) const
inlineconstexpr

References set_as().

◆ without()

WARN_UNUSED_RESULT constexpr qualifier_set qualifier_set::without ( cv_qualifier qual) const
inlineconstexpr

References remove().

◆ operator!=

bool operator!= ( const qualifier_set & a,
const qualifier_set & b )
friend

References a, b, and qualifier_set().

◆ operator==

bool operator== ( const qualifier_set & a,
const qualifier_set & b )
friend

References a, b, and qualifier_set().

Field Documentation

◆ m_addr_space

addr_space_t qualifier_set::m_addr_space
private

◆ m_cv_quals

cv_qualifier qualifier_set::m_cv_quals
private

The documentation for this struct was generated from the following files: