gcc/d/dmd/aggregate.h

   1
   2 /* Compiler implementation of the D programming language
   3  * Copyright (C) 1999-2024 by The D Language Foundation, All Rights Reserved
   4  * written by Walter Bright
   5  * https://www.digitalmars.com
   6  * Distributed under the Boost Software License, Version 1.0.
   7  * https://www.boost.org/LICENSE_1_0.txt
   8  * https://github.com/dlang/dmd/blob/master/src/dmd/aggregate.h
   9  */
  10
  11 #pragma once
  12
  13 #include "dsymbol.h"
  14 #include "objc.h"
  15
  16 class AliasThis;
  17 class Identifier;
  18 class Type;
  19 class TypeFunction;
  20 class Expression;
  21 class FuncDeclaration;
  22 class CtorDeclaration;
  23 class DtorDeclaration;
  24 class InterfaceDeclaration;
  25 class TypeInfoClassDeclaration;
  26 class VarDeclaration;
  27
  28 enum class Sizeok : uint8_t
  29 {
  30     none,         // size of aggregate is not yet able to compute
  31     fwd,          // size of aggregate is ready to compute
  32     inProcess,    // in the midst of computing the size
  33     done          // size of aggregate is set correctly
  34 };
  35
  36 enum class Baseok : uint8_t
  37 {
  38     none,         // base classes not computed yet
  39     in,           // in process of resolving base classes
  40     done,         // all base classes are resolved
  41     semanticdone  // all base classes semantic done
  42 };
  43
  44 namespace dmd
  45 {
  46     FuncDeclaration *search_toString(StructDeclaration *sd);
  47     void semanticTypeInfoMembers(StructDeclaration *sd);
  48 }
  49
  50 enum class ClassKind : uint8_t
  51 {
  52   /// the aggregate is a d(efault) struct/class/interface
  53   d,
  54   /// the aggregate is a C++ struct/class/interface
  55   cpp,
  56   /// the aggregate is an Objective-C class/interface
  57   objc,
  58   /// the aggregate is a C struct
  59   c,
  60 };
  61
  62 struct MangleOverride
  63 {
  64     Dsymbol *agg;
  65     Identifier *id;
  66 };
  67
  68 class AggregateDeclaration : public ScopeDsymbol
  69 {
  70 public:
  71     Type *type;
  72     StorageClass storage_class;
  73     unsigned structsize;        // size of struct
  74     unsigned alignsize;         // size of struct for alignment purposes
  75     VarDeclarations fields;     // VarDeclaration fields
  76     Dsymbol *deferred;          // any deferred semantic2() or semantic3() symbol
  77
  78     ClassKind classKind;        // specifies the linkage type
  79     CPPMANGLE cppmangle;
  80
  81     // overridden symbol with pragma(mangle, "...")
  82     MangleOverride *pMangleOverride;
  83     /* !=NULL if is nested
  84      * pointing to the dsymbol that directly enclosing it.
  85      * 1. The function that enclosing it (nested struct and class)
  86      * 2. The class that enclosing it (nested class only)
  87      * 3. If enclosing aggregate is template, its enclosing dsymbol.
  88      * See AggregateDeclaraton::makeNested for the details.
  89      */
  90     Dsymbol *enclosing;
  91     VarDeclaration *vthis;      // 'this' parameter if this aggregate is nested
  92     VarDeclaration *vthis2;     // 'this' parameter if this aggregate is a template and is nested
  93     // Special member functions
  94     FuncDeclarations invs;              // Array of invariants
  95     FuncDeclaration *inv;               // invariant
  96
  97     Dsymbol *ctor;                      // CtorDeclaration or TemplateDeclaration
  98
  99     // default constructor - should have no arguments, because
 100     // it would be stored in TypeInfo_Class.defaultConstructor
 101     CtorDeclaration *defaultCtor;
 102
 103     AliasThis *aliasthis;       // forward unresolved lookups to aliasthis
 104
 105     DtorDeclarations userDtors; // user-defined destructors (`~this()`) - mixins can yield multiple ones
 106     DtorDeclaration *aggrDtor;  // aggregate destructor calling userDtors and fieldDtor (and base class aggregate dtor for C++ classes)
 107     DtorDeclaration *dtor;      // the aggregate destructor exposed as `__xdtor` alias
 108                                 // (same as aggrDtor, except for C++ classes with virtual dtor on Windows)
 109     DtorDeclaration *tidtor;    // aggregate destructor used in TypeInfo (must have extern(D) ABI)
 110     DtorDeclaration *fieldDtor; // function destructing (non-inherited) fields
 111
 112     Expression *getRTInfo;      // pointer to GC info generated by object.RTInfo(this)
 113
 114     Visibility visibility;
 115     d_bool noDefaultCtor;         // no default construction
 116     d_bool disableNew;            // disallow allocations using `new`
 117     Sizeok sizeok;              // set when structsize contains valid data
 118
 119     virtual Scope *newScope(Scope *sc);
 120     virtual void finalizeSize() = 0;
 121     uinteger_t size(const Loc &loc) override final;
 122     bool fill(const Loc &loc, Expressions &elements, bool ctorinit);
 123     Type *getType() override final;
 124     bool isDeprecated() const override final; // is aggregate deprecated?
 125     bool isNested() const;
 126     bool isExport() const override final;
 127
 128     Visibility visible() override final;
 129
 130     // 'this' type
 131     Type *handleType() { return type; }
 132
 133     bool hasInvariant();
 134
 135     // Back end
 136     void *sinit;
 137
 138     AggregateDeclaration *isAggregateDeclaration() override final { return this; }
 139     void accept(Visitor *v) override { v->visit(this); }
 140 };
 141
 142 struct StructFlags
 143 {
 144     enum Type
 145     {
 146         none = 0x0,
 147         hasPointers = 0x1  // NB: should use noPointers as in ClassFlags
 148     };
 149 };
 150
 151 class StructDeclaration : public AggregateDeclaration
 152 {
 153 public:
 154     FuncDeclarations postblits; // Array of postblit functions
 155     FuncDeclaration *postblit;  // aggregate postblit
 156
 157     FuncDeclaration *xeq;       // TypeInfo_Struct.xopEquals
 158     FuncDeclaration *xcmp;      // TypeInfo_Struct.xopCmp
 159     FuncDeclaration *xhash;     // TypeInfo_Struct.xtoHash
 160     static FuncDeclaration *xerreq;      // object.xopEquals
 161     static FuncDeclaration *xerrcmp;     // object.xopCmp
 162
 163     // ABI-specific type(s) if the struct can be passed in registers
 164     TypeTuple *argTypes;
 165
 166     structalign_t alignment;    // alignment applied outside of the struct
 167     ThreeState ispod;           // if struct is POD
 168 private:
 169     uint16_t bitFields;
 170 public:
 171     static StructDeclaration *create(const Loc &loc, Identifier *id, bool inObject);
 172     StructDeclaration *syntaxCopy(Dsymbol *s) override;
 173     const char *kind() const override;
 174     void finalizeSize() override final;
 175     bool isPOD();
 176     bool zeroInit() const;          // !=0 if initialize with 0 fill
 177     bool zeroInit(bool v);
 178     bool hasIdentityAssign() const; // true if has identity opAssign
 179     bool hasIdentityAssign(bool v);
 180     bool hasBlitAssign() const;     // true if opAssign is a blit
 181     bool hasBlitAssign(bool v);
 182     bool hasIdentityEquals() const; // true if has identity opEquals
 183     bool hasIdentityEquals(bool v);
 184     bool hasNoFields() const;       // has no fields
 185     bool hasNoFields(bool v);
 186     bool hasCopyCtor() const;       // copy constructor
 187     bool hasCopyCtor(bool v);
 188     // Even if struct is defined as non-root symbol, some built-in operations
 189     // (e.g. TypeidExp, NewExp, ArrayLiteralExp, etc) request its TypeInfo.
 190     // For those, today TypeInfo_Struct is generated in COMDAT.
 191     bool requestTypeInfo() const;
 192     bool requestTypeInfo(bool v);
 193
 194     StructDeclaration *isStructDeclaration() override final { return this; }
 195     void accept(Visitor *v) override { v->visit(this); }
 196
 197     unsigned numArgTypes() const;
 198     Type *argType(unsigned index);
 199     bool hasRegularCtor(bool checkDisabled = false);
 200 };
 201
 202 class UnionDeclaration final : public StructDeclaration
 203 {
 204 public:
 205     UnionDeclaration *syntaxCopy(Dsymbol *s) override;
 206     const char *kind() const override;
 207
 208     UnionDeclaration *isUnionDeclaration() override { return this; }
 209     void accept(Visitor *v) override { v->visit(this); }
 210 };
 211
 212 struct BaseClass
 213 {
 214     Type *type;                         // (before semantic processing)
 215
 216     ClassDeclaration *sym;
 217     unsigned offset;                    // 'this' pointer offset
 218     // for interfaces: Array of FuncDeclaration's
 219     // making up the vtbl[]
 220     FuncDeclarations vtbl;
 221
 222     DArray<BaseClass> baseInterfaces;   // if BaseClass is an interface, these
 223                                         // are a copy of the InterfaceDeclaration::interfaces
 224
 225     bool fillVtbl(ClassDeclaration *cd, FuncDeclarations *vtbl, int newinstance);
 226 };
 227
 228 struct ClassFlags
 229 {
 230     enum Type
 231     {
 232         none = 0x0,
 233         isCOMclass = 0x1,
 234         noPointers = 0x2,
 235         hasOffTi = 0x4,
 236         hasCtor = 0x8,
 237         hasGetMembers = 0x10,
 238         hasTypeInfo = 0x20,
 239         isAbstract = 0x40,
 240         isCPPclass = 0x80,
 241         hasDtor = 0x100,
 242         hasNameSig = 0x200,
 243     };
 244 };
 245
 246 class ClassDeclaration : public AggregateDeclaration
 247 {
 248 public:
 249     static ClassDeclaration *object;
 250     static ClassDeclaration *throwable;
 251     static ClassDeclaration *exception;
 252     static ClassDeclaration *errorException;
 253     static ClassDeclaration *cpp_type_info_ptr;
 254
 255     ClassDeclaration *baseClass;        // NULL only if this is Object
 256     FuncDeclaration *staticCtor;
 257     FuncDeclaration *staticDtor;
 258     Dsymbols vtbl;                      // Array of FuncDeclaration's making up the vtbl[]
 259     Dsymbols vtblFinal;                 // More FuncDeclaration's that aren't in vtbl[]
 260
 261     BaseClasses *baseclasses;           // Array of BaseClass's; first is super,
 262                                         // rest are Interface's
 263
 264     DArray<BaseClass*> interfaces;      // interfaces[interfaces_dim] for this class
 265                                         // (does not include baseClass)
 266
 267     BaseClasses *vtblInterfaces;        // array of base interfaces that have
 268                                         // their own vtbl[]
 269
 270     TypeInfoClassDeclaration *vclassinfo;       // the ClassInfo object for this ClassDeclaration
 271     d_bool com;                           // true if this is a COM class (meaning it derives from IUnknown)
 272     d_bool stack;                         // true if this is a scope class
 273     int cppDtorVtblIndex;               // slot reserved for the virtual destructor [extern(C++)]
 274     d_bool inuse;                         // to prevent recursive attempts
 275
 276     ThreeState isabstract;              // if abstract class
 277     Baseok baseok;                      // set the progress of base classes resolving
 278     ObjcClassDeclaration objc;          // Data for a class declaration that is needed for the Objective-C integration
 279     Symbol *cpp_type_info_ptr_sym;      // cached instance of class Id.cpp_type_info_ptr
 280
 281     static ClassDeclaration *create(const Loc &loc, Identifier *id, BaseClasses *baseclasses, Dsymbols *members, bool inObject);
 282     const char *toPrettyChars(bool QualifyTypes = false) override;
 283     ClassDeclaration *syntaxCopy(Dsymbol *s) override;
 284     Scope *newScope(Scope *sc) override;
 285
 286     #define OFFSET_RUNTIME 0x76543210
 287     #define OFFSET_FWDREF 0x76543211
 288     virtual bool isBaseOf(ClassDeclaration *cd, int *poffset);
 289
 290     bool isBaseInfoComplete();
 291     void finalizeSize() override;
 292     bool hasMonitor();
 293     bool isFuncHidden(FuncDeclaration *fd);
 294     bool isCOMclass() const;
 295     virtual bool isCOMinterface() const;
 296     bool isCPPclass() const;
 297     virtual bool isCPPinterface() const;
 298     bool isAbstract();
 299     virtual int vtblOffset() const;
 300     const char *kind() const override;
 301
 302     void addObjcSymbols(ClassDeclarations *classes, ClassDeclarations *categories) override final;
 303
 304     // Back end
 305     Dsymbol *vtblsym;
 306     Dsymbol *vtblSymbol();
 307
 308     ClassDeclaration *isClassDeclaration() override final { return (ClassDeclaration *)this; }
 309     void accept(Visitor *v) override { v->visit(this); }
 310 };
 311
 312 class InterfaceDeclaration final : public ClassDeclaration
 313 {
 314 public:
 315     InterfaceDeclaration *syntaxCopy(Dsymbol *s) override;
 316     Scope *newScope(Scope *sc) override;
 317     bool isBaseOf(ClassDeclaration *cd, int *poffset) override;
 318     const char *kind() const override;
 319     int vtblOffset() const override;
 320     bool isCPPinterface() const override;
 321     bool isCOMinterface() const override;
 322
 323     InterfaceDeclaration *isInterfaceDeclaration() override { return this; }
 324     void accept(Visitor *v) override { v->visit(this); }
 325 };