source: src/AST/Type.hpp @ a86b2ca6

ADTarm-ehast-experimentalenumforall-pointer-decayjacob/cs343-translationnew-astnew-ast-unique-exprpthread-emulationqualifiedEnum
Last change on this file since a86b2ca6 was 923d25a, checked in by Andrew Beach <ajbeach@…>, 4 years ago

SueInstType? is a template that replaces {Struct,Union,Enum}InstType?, with using declarations keeping the interface the same.

  • Property mode set to 100644
File size: 16.4 KB
RevLine 
[2bb4a01]1//
2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// Type.hpp --
8//
9// Author           : Aaron B. Moss
10// Created On       : Thu May 9 10:00:00 2019
[923d25a]11// Last Modified By : Andrew Beach
12// Last Modified On : Thu Jul 23 14:15:00 2020
13// Update Count     : 6
[2bb4a01]14//
15
16#pragma once
17
[9e1d485]18#include <cassert>
19#include <cstddef>           // for nullptr_t
20#include <cstdint>           // for uintptr_t
21#include <utility>           // for move
22#include <vector>
23
24#include "CVQualifiers.hpp"
[9b4f329]25#include "Decl.hpp"          // for AggregateDecl subclasses
[9e1d485]26#include "Fwd.hpp"
[d76c588]27#include "Node.hpp"          // for Node, ptr, ptr_base
[9e1d485]28#include "Visitor.hpp"
[2bb4a01]29
[f3cc5b6]30// Must be included in *all* AST classes; should be #undef'd at the end of the file
[99da267]31#define MUTATE_FRIEND \
32    template<typename node_t> friend node_t * mutate(const node_t * node); \
33        template<typename node_t> friend node_t * shallowCopy(const node_t * node);
[f3cc5b6]34
[2bb4a01]35namespace ast {
36
[e0e9a0b]37template< typename T > class Pass;
[f53acdf8]38
39struct ForallSubstitutor;
[e0e9a0b]40
[2bb4a01]41class Type : public Node {
[9e1d485]42public:
[54e41b3]43        CV::Qualifiers qualifiers;
[c829320]44        std::vector<ptr<Attribute>> attributes;
[87701b6]45
[1ae47de]46        Type( CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
[c829320]47        : qualifiers(q), attributes(std::move(as)) {}
[54e41b3]48
49        bool is_const() const { return qualifiers.is_const; }
50        bool is_volatile() const { return qualifiers.is_volatile; }
51        bool is_restrict() const { return qualifiers.is_restrict; }
52        bool is_mutex() const { return qualifiers.is_mutex; }
53        bool is_atomic() const { return qualifiers.is_atomic; }
54
[76ed81f]55        Type * set_const( bool v ) { qualifiers.is_const = v; return this; }
[dafe9e1]56        Type * set_volatile( bool v ) { qualifiers.is_volatile = v; return this; }
[76ed81f]57        Type * set_restrict( bool v ) { qualifiers.is_restrict = v; return this; }
58        Type * set_mutex( bool v ) { qualifiers.is_mutex = v; return this; }
59        Type * set_atomic( bool v ) { qualifiers.is_atomic = v; return this; }
[9e1d485]60
61        /// How many elemental types are represented by this type
62        virtual unsigned size() const { return 1; }
63        /// Is this a void type?
64        virtual bool isVoid() const { return size() == 0; }
65        /// Get the i'th component of this type
[d76c588]66        virtual const Type * getComponent( unsigned i ) const;
[9e1d485]67
68        /// type without outer pointers and arrays
[d76c588]69        const Type * stripDeclarator() const;
[9e1d485]70        /// type without outer references
[d76c588]71        const Type * stripReferences() const;
[9e1d485]72        /// number of reference occuring consecutively on the outermost layer of this type
73        /// (i.e. do not count references nested within other types)
74        virtual unsigned referenceDepth() const { return 0; }
75        /// true iff type is complete type (i.e. compiler knows the size, alignment, and layout)
76        virtual bool isComplete() const { return true; }
77
[69bafd2]78        virtual const Type * accept( Visitor & v ) const override = 0;
[9e1d485]79private:
80        virtual Type * clone() const override = 0;
[f3cc5b6]81        MUTATE_FRIEND
[9e1d485]82};
83
[ee574a2]84/// Clear/reset the qualifiers on this type, cloning only if necessary
[d76c588]85template< enum Node::ref_type ref_t >
[ee574a2]86void reset_qualifiers( ptr_base< Type, ref_t > & p, CV::Qualifiers q = {} ) {
87        if ( p->qualifiers.val != q.val ) p.get_and_mutate()->qualifiers = q;
[d76c588]88}
89
[ee574a2]90/// Add the specified qualifiers to this type, cloning only if necessary
[d76c588]91template< enum Node::ref_type ref_t >
[ee574a2]92void add_qualifiers( ptr_base< Type, ref_t > & p, CV::Qualifiers q ) {
93        if ( ( p->qualifiers.val & q.val ) != q.val ) p.get_and_mutate()->qualifiers |= q;
94}
95
96/// Remove the specified qualifiers from this type, cloning only if necessary
97template< enum Node::ref_type ref_t >
98void remove_qualifiers( ptr_base< Type, ref_t > & p, CV::Qualifiers q ) {
99        if ( ( p->qualifiers.val & q.val ) != 0 ) p.get_and_mutate()->qualifiers -= q;
[d76c588]100}
101
[9e1d485]102/// `void`
103class VoidType final : public Type {
104public:
105        VoidType( CV::Qualifiers q = {} ) : Type( q ) {}
[87701b6]106
[9e1d485]107        unsigned size() const override { return 0; }
108        bool isVoid() const override { return true; }
109        bool isComplete() const override { return false; }
110
[69bafd2]111        const Type * accept( Visitor & v ) const override { return v.visit( this ); }
[9e1d485]112private:
113        VoidType * clone() const override { return new VoidType{ *this }; }
[f3cc5b6]114        MUTATE_FRIEND
[9e1d485]115};
116
117/// Built-in arithmetic type
118class BasicType final : public Type {
119public:
120        // GENERATED START, DO NOT EDIT
121        // GENERATED BY BasicTypes-gen.cc
122        enum Kind {
123                Bool,
124                Char,
125                SignedChar,
126                UnsignedChar,
127                ShortSignedInt,
128                ShortUnsignedInt,
129                SignedInt,
130                UnsignedInt,
131                LongSignedInt,
132                LongUnsignedInt,
133                LongLongSignedInt,
134                LongLongUnsignedInt,
135                SignedInt128,
136                UnsignedInt128,
137                uFloat16,
138                uFloat16Complex,
139                uFloat32,
140                uFloat32Complex,
141                Float,
142                FloatComplex,
143                uFloat32x,
144                uFloat32xComplex,
145                uFloat64,
146                uFloat64Complex,
147                Double,
148                DoubleComplex,
149                uFloat64x,
150                uFloat64xComplex,
151                uuFloat80,
152                uFloat128,
153                uFloat128Complex,
154                uuFloat128,
155                LongDouble,
156                LongDoubleComplex,
157                uFloat128x,
158                uFloat128xComplex,
159                NUMBER_OF_BASIC_TYPES
160        } kind;
161        // GENERATED END
162
163        /// xxx -- MAX_INTEGER_TYPE should probably be in BasicTypes-gen.cc, rather than hardcoded here
164        enum { MAX_INTEGER_TYPE = UnsignedInt128 };
165
166        /// string names of basic types; generated to match with Kind
167        static const char *typeNames[];
168
[f53acdf8]169        BasicType( Kind k, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
[0f6a7752]170        : Type(q, std::move(as)), kind(k) {}
[9e1d485]171
172        /// Check if this type represents an integer type
[3648d98]173        bool isInteger() const { return (unsigned)kind <= (unsigned)MAX_INTEGER_TYPE; }
[9e1d485]174
[69bafd2]175        const Type * accept( Visitor & v ) const override { return v.visit( this ); }
[9e1d485]176private:
177        BasicType * clone() const override { return new BasicType{ *this }; }
[f3cc5b6]178        MUTATE_FRIEND
[9e1d485]179};
180
181/// Pointer/array variable length?
182enum LengthFlag { FixedLen, VariableLen };
183
184/// Pointer/array static dimension?
185enum DimensionFlag { DynamicDim, StaticDim };
186
187/// Pointer type `T*`
188class PointerType final : public Type {
189public:
190        ptr<Type> base;
191
192        // In C99, pointer types can be qualified in many ways, e.g. `int a[ static 3 ]`
193        ptr<Expr> dimension;
194        LengthFlag isVarLen = FixedLen;
195        DimensionFlag isStatic = DynamicDim;
196
197        PointerType( const Type * b, CV::Qualifiers q = {} ) : Type(q), base(b), dimension() {}
[87701b6]198        PointerType( const Type * b, const Expr * d, LengthFlag vl, DimensionFlag s,
[9e1d485]199                CV::Qualifiers q = {} ) : Type(q), base(b), dimension(d), isVarLen(vl), isStatic(s) {}
200
201        // true if this pointer is actually an array
202        bool isArray() const { return isVarLen || isStatic || dimension; }
203
204        bool isComplete() const override { return ! isVarLen; }
205
[69bafd2]206        const Type * accept( Visitor & v ) const override { return v.visit( this ); }
[9e1d485]207private:
208        PointerType * clone() const override { return new PointerType{ *this }; }
[f3cc5b6]209        MUTATE_FRIEND
[9e1d485]210};
211
212/// Array type `T[]`
213class ArrayType final : public Type {
214public:
215        ptr<Type> base;
216        ptr<Expr> dimension;
217        LengthFlag isVarLen;
218        DimensionFlag isStatic;
[2bb4a01]219
[87701b6]220        ArrayType( const Type * b, const Expr * d, LengthFlag vl, DimensionFlag s,
[9e1d485]221                CV::Qualifiers q = {} ) : Type(q), base(b), dimension(d), isVarLen(vl), isStatic(s) {}
222
223        // array types are complete if they have a dimension expression or are
224        // VLAs ('*' in parameter declaration), and incomplete otherwise.
225        // See 6.7.6.2
226        bool isComplete() const override { return dimension || isVarLen; }
227
[69bafd2]228        const Type * accept( Visitor & v ) const override { return v.visit( this ); }
[9e1d485]229private:
230        ArrayType * clone() const override { return new ArrayType{ *this }; }
[f3cc5b6]231        MUTATE_FRIEND
[9e1d485]232};
233
234/// Reference type `T&`
235class ReferenceType final : public Type {
236public:
237        ptr<Type> base;
238
239        ReferenceType( const Type * b, CV::Qualifiers q = {} ) : Type(q), base(b) {}
240
241        unsigned referenceDepth() const override { return base->referenceDepth() + 1; }
242
243        // Since reference types act like value types, their size is the size of the base.
244        // This makes it simple to cast the empty tuple to a reference type, since casts that increase
245        // the number of values are disallowed.
246        unsigned size() const override { return base->size(); }
247
[69bafd2]248        const Type * accept( Visitor & v ) const override { return v.visit( this ); }
[9e1d485]249private:
250        ReferenceType * clone() const override { return new ReferenceType{ *this }; }
[f3cc5b6]251        MUTATE_FRIEND
[2bb4a01]252};
253
[9e1d485]254/// Qualified type `P.C`
255class QualifiedType final : public Type {
256public:
257        ptr<Type> parent;
258        ptr<Type> child;
259
[87701b6]260        QualifiedType( const Type * p, const Type * c, CV::Qualifiers q = {} )
[9e1d485]261        : Type(q), parent(p), child(c) {}
262
[69bafd2]263        const Type * accept( Visitor & v ) const override { return v.visit( this ); }
[9e1d485]264private:
265        QualifiedType * clone() const override { return new QualifiedType{ *this }; }
[f3cc5b6]266        MUTATE_FRIEND
[9e1d485]267};
268
269/// Base type for potentially forall-qualified types
270class ParameterizedType : public Type {
[e0e9a0b]271protected:
272        /// initializes forall with substitutor
273        void initWithSub( const ParameterizedType & o, Pass< ForallSubstitutor > & sub );
[9e1d485]274public:
275        using ForallList = std::vector<ptr<TypeDecl>>;
276
277        ForallList forall;
278
[1ae47de]279        ParameterizedType( ForallList&& fs = {}, CV::Qualifiers q = {},
[c829320]280                std::vector<ptr<Attribute>> && as = {} )
281        : Type(q, std::move(as)), forall(std::move(fs)) {}
[1ae47de]282
283        ParameterizedType( CV::Qualifiers q, std::vector<ptr<Attribute>> && as = {} )
[c829320]284        : Type(q, std::move(as)), forall() {}
[9e1d485]285
[e0e9a0b]286        // enforce use of ForallSubstitutor to copy parameterized type
287        ParameterizedType( const ParameterizedType & ) = delete;
[92f5279]288
289        ParameterizedType( ParameterizedType && ) = default;
290
291        // no need to change destructor, and operator= deleted in Node
292
[9e1d485]293private:
294        virtual ParameterizedType * clone() const override = 0;
[f3cc5b6]295        MUTATE_FRIEND
[9e1d485]296};
297
298/// Function variable arguments flag
299enum ArgumentFlag { FixedArgs, VariableArgs };
300
301/// Type of a function `[R1, R2](*)(P1, P2, P3)`
302class FunctionType final : public ParameterizedType {
303public:
[54e41b3]304        std::vector<ptr<DeclWithType>> returns;
305        std::vector<ptr<DeclWithType>> params;
[9e1d485]306
[87701b6]307        /// Does the function accept a variable number of arguments following the arguments specified
[9e1d485]308        /// in the parameters list.
309        /// This could be because of
310        /// - an ellipsis in a prototype declaration
311        /// - an unprototyped declaration
312        ArgumentFlag isVarArgs;
313
314        FunctionType( ArgumentFlag va = FixedArgs, CV::Qualifiers q = {} )
[54e41b3]315        : ParameterizedType(q), returns(), params(), isVarArgs(va) {}
[9e1d485]316
[e0e9a0b]317        FunctionType( const FunctionType & o );
318
[9e1d485]319        /// true if either the parameters or return values contain a tttype
320        bool isTtype() const;
321        /// true if function parameters are unconstrained by prototype
[54e41b3]322        bool isUnprototyped() const { return isVarArgs && params.size() == 0; }
[9e1d485]323
[69bafd2]324        const Type * accept( Visitor & v ) const override { return v.visit( this ); }
[9e1d485]325private:
326        FunctionType * clone() const override { return new FunctionType{ *this }; }
[f3cc5b6]327        MUTATE_FRIEND
[9e1d485]328};
329
330/// base class for types that refer to types declared elsewhere (aggregates and typedefs)
331class ReferenceToType : public ParameterizedType {
[e0e9a0b]332protected:
333        /// Initializes forall and parameters based on substitutor
334        void initWithSub( const ReferenceToType & o, Pass< ForallSubstitutor > & sub );
[9e1d485]335public:
[54e41b3]336        std::vector<ptr<Expr>> params;
[9e1d485]337        std::string name;
338        bool hoistType = false;
339
[f53acdf8]340        ReferenceToType(
[e0e9a0b]341                const std::string& n, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
[c829320]342        : ParameterizedType(q, std::move(as)), params(), name(n) {}
[9e1d485]343
[e0e9a0b]344        ReferenceToType( const ReferenceToType & o );
345
[9e1d485]346        /// Gets aggregate declaration this type refers to
347        virtual const AggregateDecl * aggr() const = 0;
348        /// Looks up member declarations with given name
349        std::vector<readonly<Decl>> lookup( const std::string & name ) const;
350
351private:
352        virtual ReferenceToType * clone() const override = 0;
[f3cc5b6]353        MUTATE_FRIEND
[9e1d485]354};
355
[923d25a]356// Common implementation for the SUE instance types. Not to be used directly.
357template<typename decl_t>
358class SueInstType final : public ReferenceToType {
[9e1d485]359public:
[923d25a]360        using base_type = decl_t;
361        readonly<decl_t> base;
[9e1d485]362
[923d25a]363        SueInstType(
[e0e9a0b]364                const std::string& n, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
[9e1d485]365        : ReferenceToType( n, q, std::move(as) ), base() {}
[e0e9a0b]366
[923d25a]367        SueInstType(
368                const decl_t * b, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} );
[87701b6]369
[9e1d485]370        bool isComplete() const override;
371
[923d25a]372        const decl_t * aggr() const override { return base; }
[9e1d485]373
[69bafd2]374        const Type * accept( Visitor & v ) const override { return v.visit( this ); }
[9e1d485]375private:
[923d25a]376        SueInstType<decl_t> * clone() const override { return new SueInstType<decl_t>{ *this }; }
[f3cc5b6]377        MUTATE_FRIEND
[9e1d485]378};
379
[923d25a]380/// An instance of a struct type.
381using StructInstType = SueInstType<StructDecl>;
[9e1d485]382
[923d25a]383/// An instance of a union type.
384using UnionInstType = SueInstType<UnionDecl>;
[9e1d485]385
[923d25a]386/// An instance of an enum type.
387using EnumInstType = SueInstType<EnumDecl>;
[9e1d485]388
[923d25a]389/// An instance of a trait type.
[9e1d485]390class TraitInstType final : public ReferenceToType {
391public:
392        readonly<TraitDecl> base;
393
[f53acdf8]394        TraitInstType(
[e0e9a0b]395                const std::string& n, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
[9e1d485]396        : ReferenceToType( n, q, std::move(as) ), base() {}
[f53acdf8]397
398        TraitInstType(
[e0e9a0b]399                const TraitDecl * b, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} );
[87701b6]400
[9e1d485]401        // not meaningful for TraitInstType
402        bool isComplete() const override { assert(false); }
403
404        const TraitDecl * aggr() const override { return base; }
405
[69bafd2]406        const Type * accept( Visitor & v ) const override { return v.visit( this ); }
[9e1d485]407private:
408        TraitInstType * clone() const override { return new TraitInstType{ *this }; }
[f3cc5b6]409        MUTATE_FRIEND
[9e1d485]410};
411
412/// instance of named type alias (typedef or variable)
413class TypeInstType final : public ReferenceToType {
414public:
415        readonly<TypeDecl> base;
[07de76b]416        TypeDecl::Kind kind;
[9e1d485]417
[f53acdf8]418        TypeInstType(
[e0e9a0b]419                const std::string& n, const TypeDecl * b, CV::Qualifiers q = {},
[9e1d485]420                std::vector<ptr<Attribute>> && as = {} )
421        : ReferenceToType( n, q, std::move(as) ), base( b ), kind( b->kind ) {}
[07de76b]422        TypeInstType( const std::string& n, TypeDecl::Kind k, CV::Qualifiers q = {},
[9e1d485]423                std::vector<ptr<Attribute>> && as = {} )
424        : ReferenceToType( n, q, std::move(as) ), base(), kind( k ) {}
425
[e0e9a0b]426        TypeInstType( const TypeInstType & o );
427
[9e1d485]428        /// sets `base`, updating `kind` correctly
429        void set_base( const TypeDecl * );
430
431        bool isComplete() const override;
432
433        // not meaningful for TypeInstType
434        const AggregateDecl * aggr() const override { assert(false); }
435
[69bafd2]436        const Type * accept( Visitor & v ) const override { return v.visit( this ); }
[9e1d485]437private:
438        TypeInstType * clone() const override { return new TypeInstType{ *this }; }
[f3cc5b6]439        MUTATE_FRIEND
[9e1d485]440};
441
442/// tuple type e.g. `[int, char]`
443class TupleType final : public Type {
444public:
445        std::vector<ptr<Type>> types;
446        std::vector<ptr<Decl>> members;
447
448        TupleType( std::vector<ptr<Type>> && ts, CV::Qualifiers q = {} );
449
450        // collection simulation
451        using iterator = std::vector<ptr<Type>>::const_iterator;
452        iterator begin() const { return types.begin(); }
453        iterator end() const { return types.end(); }
[87701b6]454
[9e1d485]455        unsigned size() const override { return types.size(); }
456
[d76c588]457        const Type * getComponent( unsigned i ) const override {
[87701b6]458                assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d",
[9e1d485]459                        i, size() );
460                return *(begin()+i);
461        }
462
[69bafd2]463        const Type * accept( Visitor & v ) const override { return v.visit( this ); }
[9e1d485]464private:
465        TupleType * clone() const override { return new TupleType{ *this }; }
[f3cc5b6]466        MUTATE_FRIEND
[9e1d485]467};
468
469/// Type of unresolved `typeof()` expression
470class TypeofType : public Type {
471public:
472        ptr<Expr> expr;
473        enum Kind { Typeof, Basetypeof } kind;
474
[87701b6]475        TypeofType( const Expr * e, Kind k = Typeof, CV::Qualifiers q = {} )
[9e1d485]476        : Type(q), expr(e), kind(k) {}
477
[69bafd2]478        const Type * accept( Visitor & v ) const override { return v.visit( this ); }
[9e1d485]479private:
480        TypeofType * clone() const override { return new TypeofType{ *this }; }
[f3cc5b6]481        MUTATE_FRIEND
[9e1d485]482};
483
484/// GCC built-in varargs type
485class VarArgsType final : public Type {
486public:
487        VarArgsType( CV::Qualifiers q = {} ) : Type( q ) {}
[87701b6]488
[69bafd2]489        const Type * accept( Visitor & v ) const override { return v.visit( this ); }
[9e1d485]490private:
491        VarArgsType * clone() const override { return new VarArgsType{ *this }; }
[f3cc5b6]492        MUTATE_FRIEND
[9e1d485]493};
494
495/// Type of zero constant `0`
496class ZeroType final : public Type {
497public:
498        ZeroType( CV::Qualifiers q = {} ) : Type( q ) {}
[87701b6]499
[69bafd2]500        const Type * accept( Visitor & v ) const override { return v.visit( this ); }
[9e1d485]501private:
[f3cc5b6]502        ZeroType * clone() const override { return new ZeroType{ *this }; }
503        MUTATE_FRIEND
[9e1d485]504};
505
506/// Type of one constant `1`
507class OneType final : public Type {
508public:
509        OneType( CV::Qualifiers q = {} ) : Type( q ) {}
510
[69bafd2]511        const Type * accept( Visitor & v ) const override { return v.visit( this ); }
[9e1d485]512private:
513        OneType * clone() const override { return new OneType{ *this }; }
[f3cc5b6]514        MUTATE_FRIEND
[9e1d485]515};
516
517/// Parent type for scope-qualified types at global scope
518class GlobalScopeType final : public Type {
519public:
[746ae82]520        GlobalScopeType() : Type() {}
[9e1d485]521
[69bafd2]522        const Type * accept( Visitor & v ) const override { return v.visit( this ); }
[9e1d485]523private:
524        GlobalScopeType * clone() const override { return new GlobalScopeType{ *this }; }
[f3cc5b6]525        MUTATE_FRIEND
[9e1d485]526};
[e0115286]527
[2bb4a01]528}
529
[f3cc5b6]530#undef MUTATE_FRIEND
531
[2bb4a01]532// Local Variables: //
533// tab-width: 4 //
534// mode: c++ //
535// compile-command: "make install" //
536// End: //
Note: See TracBrowser for help on using the repository browser.