gcc/d/dmd/dstruct.d

   1 /**
   2  * Struct and union declarations.
   3  *
   4  * Specification: $(LINK2 https://dlang.org/spec/struct.html, Structs, Unions)
   5  *
   6  * Copyright:   Copyright (C) 1999-2023 by The D Language Foundation, All Rights Reserved
   7  * Authors:     $(LINK2 https://www.digitalmars.com, Walter Bright)
   8  * License:     $(LINK2 https://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
   9  * Source:      $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/dstruct.d, _dstruct.d)
  10  * Documentation:  https://dlang.org/phobos/dmd_dstruct.html
  11  * Coverage:    https://codecov.io/gh/dlang/dmd/src/master/src/dmd/dstruct.d
  12  */
  13
  14 module dmd.dstruct;
  15
  16 import dmd.aggregate;
  17 import dmd.arraytypes;
  18 import dmd.astenums;
  19 import dmd.attrib;
  20 import dmd.declaration;
  21 import dmd.dmodule;
  22 import dmd.dscope;
  23 import dmd.dsymbol;
  24 import dmd.dsymbolsem;
  25 import dmd.dtemplate;
  26 import dmd.errors;
  27 import dmd.expression;
  28 import dmd.func;
  29 import dmd.globals;
  30 import dmd.id;
  31 import dmd.identifier;
  32 import dmd.location;
  33 import dmd.mtype;
  34 import dmd.opover;
  35 import dmd.target;
  36 import dmd.tokens;
  37 import dmd.typesem;
  38 import dmd.typinf;
  39 import dmd.visitor;
  40
  41 /***************************************
  42  * Search sd for a member function of the form:
  43  *   `extern (D) string toString();`
  44  * Params:
  45  *   sd = struct declaration to search
  46  * Returns:
  47  *   FuncDeclaration of `toString()` if found, `null` if not
  48  */
  49 extern (C++) FuncDeclaration search_toString(StructDeclaration sd)
  50 {
  51     Dsymbol s = search_function(sd, Id.tostring);
  52     FuncDeclaration fd = s ? s.isFuncDeclaration() : null;
  53     if (fd)
  54     {
  55         __gshared TypeFunction tftostring;
  56         if (!tftostring)
  57         {
  58             tftostring = new TypeFunction(ParameterList(), Type.tstring, LINK.d);
  59             tftostring = tftostring.merge().toTypeFunction();
  60         }
  61         fd = fd.overloadExactMatch(tftostring);
  62     }
  63     return fd;
  64 }
  65
  66 /***************************************
  67  * Request additional semantic analysis for TypeInfo generation.
  68  * Params:
  69  *      sc = context
  70  *      t = type that TypeInfo is being generated for
  71  */
  72 extern (C++) void semanticTypeInfo(Scope* sc, Type t)
  73 {
  74     if (sc)
  75     {
  76         if (sc.intypeof)
  77             return;
  78         if (sc.flags & (SCOPE.ctfe | SCOPE.compile | SCOPE.ctfeBlock))
  79             return;
  80     }
  81
  82     if (!t)
  83         return;
  84
  85     void visitVector(TypeVector t)
  86     {
  87         semanticTypeInfo(sc, t.basetype);
  88     }
  89
  90     void visitAArray(TypeAArray t)
  91     {
  92         semanticTypeInfo(sc, t.index);
  93         semanticTypeInfo(sc, t.next);
  94     }
  95
  96     void visitStruct(TypeStruct t)
  97     {
  98         //printf("semanticTypeInfo.visit(TypeStruct = %s)\n", t.toChars());
  99         StructDeclaration sd = t.sym;
 100
 101         /* Step 1: create TypeInfoDeclaration
 102          */
 103         if (!sc) // inline may request TypeInfo.
 104         {
 105             Scope scx;
 106             scx._module = sd.getModule();
 107             getTypeInfoType(sd.loc, t, &scx);
 108             sd.requestTypeInfo = true;
 109         }
 110         else if (!sc.minst)
 111         {
 112             // don't yet have to generate TypeInfo instance if
 113             // the typeid(T) expression exists in speculative scope.
 114         }
 115         else
 116         {
 117             getTypeInfoType(sd.loc, t, sc);
 118             sd.requestTypeInfo = true;
 119
 120             // https://issues.dlang.org/show_bug.cgi?id=15149
 121             // if the typeid operand type comes from a
 122             // result of auto function, it may be yet speculative.
 123             // unSpeculative(sc, sd);
 124         }
 125
 126         /* Step 2: If the TypeInfo generation requires sd.semantic3, run it later.
 127          * This should be done even if typeid(T) exists in speculative scope.
 128          * Because it may appear later in non-speculative scope.
 129          */
 130         if (!sd.members)
 131             return; // opaque struct
 132         if (!sd.xeq && !sd.xcmp && !sd.postblit && !sd.tidtor && !sd.xhash && !search_toString(sd))
 133             return; // none of TypeInfo-specific members
 134
 135         // If the struct is in a non-root module, run semantic3 to get
 136         // correct symbols for the member function.
 137         if (sd.semanticRun >= PASS.semantic3)
 138         {
 139             // semantic3 is already done
 140         }
 141         else if (TemplateInstance ti = sd.isInstantiated())
 142         {
 143             if (ti.minst && !ti.minst.isRoot())
 144                 Module.addDeferredSemantic3(sd);
 145         }
 146         else
 147         {
 148             if (sd.inNonRoot())
 149             {
 150                 //printf("deferred sem3 for TypeInfo - sd = %s, inNonRoot = %d\n", sd.toChars(), sd.inNonRoot());
 151                 Module.addDeferredSemantic3(sd);
 152             }
 153         }
 154     }
 155
 156     void visitTuple(TypeTuple t)
 157     {
 158         if (t.arguments)
 159         {
 160             foreach (arg; *t.arguments)
 161             {
 162                 semanticTypeInfo(sc, arg.type);
 163             }
 164         }
 165     }
 166
 167     /* Note structural similarity of this Type walker to that in isSpeculativeType()
 168      */
 169
 170     Type tb = t.toBasetype();
 171     switch (tb.ty)
 172     {
 173         case Tvector:   visitVector(tb.isTypeVector()); break;
 174         case Taarray:   visitAArray(tb.isTypeAArray()); break;
 175         case Tstruct:   visitStruct(tb.isTypeStruct()); break;
 176         case Ttuple:    visitTuple (tb.isTypeTuple());  break;
 177
 178         case Tclass:
 179         case Tenum:     break;
 180
 181         default:        semanticTypeInfo(sc, tb.nextOf()); break;
 182     }
 183 }
 184
 185 enum StructFlags : int
 186 {
 187     none        = 0x0,
 188     hasPointers = 0x1, // NB: should use noPointers as in ClassFlags
 189 }
 190
 191 /***********************************************************
 192  * All `struct` declarations are an instance of this.
 193  */
 194 extern (C++) class StructDeclaration : AggregateDeclaration
 195 {
 196     FuncDeclarations postblits; // Array of postblit functions
 197     FuncDeclaration postblit;   // aggregate postblit
 198
 199     FuncDeclaration xeq;        // TypeInfo_Struct.xopEquals
 200     FuncDeclaration xcmp;       // TypeInfo_Struct.xopCmp
 201     FuncDeclaration xhash;      // TypeInfo_Struct.xtoHash
 202     extern (C++) __gshared FuncDeclaration xerreq;   // object.xopEquals
 203     extern (C++) __gshared FuncDeclaration xerrcmp;  // object.xopCmp
 204
 205     // ABI-specific type(s) if the struct can be passed in registers
 206     TypeTuple argTypes;
 207
 208     structalign_t alignment;    // alignment applied outside of the struct
 209     ThreeState ispod;           // if struct is POD
 210
 211     // `bool` fields that are compacted into bit fields in a string mixin
 212     private extern (D) static struct BitFields
 213     {
 214         bool zeroInit;              // !=0 if initialize with 0 fill
 215         bool hasIdentityAssign;     // true if has identity opAssign
 216         bool hasBlitAssign;         // true if opAssign is a blit
 217         bool hasIdentityEquals;     // true if has identity opEquals
 218         bool hasNoFields;           // has no fields
 219         bool hasCopyCtor;           // copy constructor
 220         bool hasPointerField;       // members with indirections
 221         bool hasVoidInitPointers;   // void-initialized unsafe fields
 222         bool hasSystemFields;      // @system members
 223         bool hasFieldWithInvariant; // invariants
 224         bool computedTypeProperties;// the above 3 fields are computed
 225         // Even if struct is defined as non-root symbol, some built-in operations
 226         // (e.g. TypeidExp, NewExp, ArrayLiteralExp, etc) request its TypeInfo.
 227         // For those, today TypeInfo_Struct is generated in COMDAT.
 228         bool requestTypeInfo;
 229     }
 230
 231     import dmd.common.bitfields : generateBitFields;
 232     mixin(generateBitFields!(BitFields, ushort));
 233
 234     extern (D) this(const ref Loc loc, Identifier id, bool inObject)
 235     {
 236         super(loc, id);
 237         zeroInit = false; // assume false until we do semantic processing
 238         ispod = ThreeState.none;
 239         // For forward references
 240         type = new TypeStruct(this);
 241
 242         if (inObject)
 243         {
 244             if (id == Id.ModuleInfo && !Module.moduleinfo)
 245                 Module.moduleinfo = this;
 246         }
 247     }
 248
 249     static StructDeclaration create(const ref Loc loc, Identifier id, bool inObject)
 250     {
 251         return new StructDeclaration(loc, id, inObject);
 252     }
 253
 254     override StructDeclaration syntaxCopy(Dsymbol s)
 255     {
 256         StructDeclaration sd =
 257             s ? cast(StructDeclaration)s
 258               : new StructDeclaration(loc, ident, false);
 259         ScopeDsymbol.syntaxCopy(sd);
 260         return sd;
 261     }
 262
 263     override final Dsymbol search(const ref Loc loc, Identifier ident, int flags = SearchLocalsOnly)
 264     {
 265         //printf("%s.StructDeclaration::search('%s', flags = x%x)\n", toChars(), ident.toChars(), flags);
 266         if (_scope && !symtab)
 267             dsymbolSemantic(this, _scope);
 268
 269         if (!members || !symtab) // opaque or semantic() is not yet called
 270         {
 271             // .stringof is always defined (but may be hidden by some other symbol)
 272             if(ident != Id.stringof && !(flags & IgnoreErrors) && semanticRun < PASS.semanticdone)
 273                 error("is forward referenced when looking for `%s`", ident.toChars());
 274             return null;
 275         }
 276
 277         return ScopeDsymbol.search(loc, ident, flags);
 278     }
 279
 280     override const(char)* kind() const
 281     {
 282         return "struct";
 283     }
 284
 285     override final void finalizeSize()
 286     {
 287         //printf("StructDeclaration::finalizeSize() %s, sizeok = %d\n", toChars(), sizeok);
 288         assert(sizeok != Sizeok.done);
 289
 290         if (sizeok == Sizeok.inProcess)
 291         {
 292             return;
 293         }
 294         sizeok = Sizeok.inProcess;
 295
 296         //printf("+StructDeclaration::finalizeSize() %s, fields.length = %d, sizeok = %d\n", toChars(), fields.length, sizeok);
 297
 298         fields.setDim(0);   // workaround
 299
 300         // Set the offsets of the fields and determine the size of the struct
 301         FieldState fieldState;
 302         bool isunion = isUnionDeclaration() !is null;
 303         for (size_t i = 0; i < members.length; i++)
 304         {
 305             Dsymbol s = (*members)[i];
 306             s.setFieldOffset(this, fieldState, isunion);
 307         }
 308         if (type.ty == Terror)
 309         {
 310             errors = true;
 311             return;
 312         }
 313
 314         if (structsize == 0)
 315         {
 316             hasNoFields = true;
 317             alignsize = 1;
 318
 319             // A fine mess of what size a zero sized struct should be
 320             final switch (classKind)
 321             {
 322                 case ClassKind.d:
 323                 case ClassKind.cpp:
 324                     structsize = 1;
 325                     break;
 326
 327                 case ClassKind.c:
 328                 case ClassKind.objc:
 329                     if (target.c.bitFieldStyle == TargetC.BitFieldStyle.MS)
 330                     {
 331                         /* Undocumented MS behavior for:
 332                          *   struct S { int :0; };
 333                          */
 334                         structsize = 4;
 335                     }
 336                     else if (target.c.bitFieldStyle == TargetC.BitFieldStyle.DM)
 337                     {
 338                         structsize = 0;
 339                         alignsize = 0;
 340                     }
 341                     else
 342                         structsize = 0;
 343                     break;
 344             }
 345         }
 346
 347         // Round struct size up to next alignsize boundary.
 348         // This will ensure that arrays of structs will get their internals
 349         // aligned properly.
 350         if (alignment.isDefault() || alignment.isPack())
 351             structsize = (structsize + alignsize - 1) & ~(alignsize - 1);
 352         else
 353             structsize = (structsize + alignment.get() - 1) & ~(alignment.get() - 1);
 354
 355         sizeok = Sizeok.done;
 356
 357         //printf("-StructDeclaration::finalizeSize() %s, fields.length = %d, structsize = %d\n", toChars(), fields.length, structsize);
 358
 359         if (errors)
 360             return;
 361
 362         // Calculate fields[i].overlapped
 363         if (checkOverlappedFields())
 364         {
 365             errors = true;
 366             return;
 367         }
 368
 369         // Determine if struct is all zeros or not
 370         zeroInit = true;
 371         foreach (vd; fields)
 372         {
 373             if (vd._init)
 374             {
 375                 if (vd._init.isVoidInitializer())
 376                     /* Treat as 0 for the purposes of putting the initializer
 377                      * in the BSS segment, or doing a mass set to 0
 378                      */
 379                     continue;
 380
 381                 // Zero size fields are zero initialized
 382                 if (vd.type.size(vd.loc) == 0)
 383                     continue;
 384
 385                 // Examine init to see if it is all 0s.
 386                 auto exp = vd.getConstInitializer();
 387                 if (!exp || !_isZeroInit(exp))
 388                 {
 389                     zeroInit = false;
 390                     break;
 391                 }
 392             }
 393             else if (!vd.type.isZeroInit(loc))
 394             {
 395                 zeroInit = false;
 396                 break;
 397             }
 398         }
 399
 400
 401         argTypes = target.toArgTypes(type);
 402     }
 403
 404     /// Compute cached type properties for `TypeStruct`
 405     extern(D) final void determineTypeProperties()
 406     {
 407         if (computedTypeProperties)
 408             return;
 409         foreach (vd; fields)
 410         {
 411             if (vd.storage_class & STC.ref_ || vd.hasPointers())
 412                 hasPointerField = true;
 413
 414             if (vd._init && vd._init.isVoidInitializer() && vd.type.hasPointers())
 415                 hasVoidInitPointers = true;
 416
 417             if (vd.storage_class & STC.system || vd.type.hasSystemFields())
 418                 hasSystemFields = true;
 419
 420             if (!vd._init && vd.type.hasVoidInitPointers())
 421                 hasVoidInitPointers = true;
 422
 423             if (vd.type.hasInvariant())
 424                 hasFieldWithInvariant = true;
 425         }
 426         computedTypeProperties = true;
 427     }
 428
 429     /***************************************
 430      * Determine if struct is POD (Plain Old Data).
 431      *
 432      * POD is defined as:
 433      *      $(OL
 434      *      $(LI not nested)
 435      *      $(LI no postblits, destructors, or assignment operators)
 436      *      $(LI no `ref` fields or fields that are themselves non-POD)
 437      *      )
 438      * The idea being these are compatible with C structs.
 439      *
 440      * Returns:
 441      *     true if struct is POD
 442      */
 443     final bool isPOD()
 444     {
 445         // If we've already determined whether this struct is POD.
 446         if (ispod != ThreeState.none)
 447             return (ispod == ThreeState.yes);
 448
 449         ispod = ThreeState.yes;
 450
 451         if (enclosing || postblit || dtor || hasCopyCtor)
 452         {
 453             ispod = ThreeState.no;
 454             return false;
 455         }
 456
 457         // Recursively check all fields are POD.
 458         for (size_t i = 0; i < fields.length; i++)
 459         {
 460             VarDeclaration v = fields[i];
 461             if (v.storage_class & STC.ref_)
 462             {
 463                 ispod = ThreeState.no;
 464                 return false;
 465             }
 466
 467             Type tv = v.type.baseElemOf();
 468             if (tv.ty == Tstruct)
 469             {
 470                 TypeStruct ts = cast(TypeStruct)tv;
 471                 StructDeclaration sd = ts.sym;
 472                 if (!sd.isPOD())
 473                 {
 474                     ispod = ThreeState.no;
 475                     return false;
 476                 }
 477             }
 478         }
 479
 480         return (ispod == ThreeState.yes);
 481     }
 482
 483     /***************************************
 484      * Determine if struct has copy construction (copy constructor or postblit)
 485      * Returns:
 486      *     true if struct has copy construction
 487      */
 488     final bool hasCopyConstruction()
 489     {
 490         return postblit || hasCopyCtor;
 491     }
 492
 493     override final inout(StructDeclaration) isStructDeclaration() inout @nogc nothrow pure @safe
 494     {
 495         return this;
 496     }
 497
 498     override void accept(Visitor v)
 499     {
 500         v.visit(this);
 501     }
 502
 503     final uint numArgTypes() const
 504     {
 505         return argTypes && argTypes.arguments ? cast(uint) argTypes.arguments.length : 0;
 506     }
 507
 508     final Type argType(uint index)
 509     {
 510         return index < numArgTypes() ? (*argTypes.arguments)[index].type : null;
 511     }
 512
 513
 514     /***************************************
 515      * Verifies whether the struct declaration has a
 516      * constructor that is not a copy constructor.
 517      * Optionally, it can check whether the struct
 518      * declaration has a regular constructor, that
 519      * is not disabled.
 520      *
 521      * Params:
 522      *      checkDisabled = if the struct has a regular
 523                             non-disabled constructor
 524      * Returns:
 525      *      true, if the struct has a regular (optionally,
 526      *      not disabled) constructor, false otherwise.
 527      */
 528     final bool hasRegularCtor(bool checkDisabled = false)
 529     {
 530         if (!ctor)
 531             return false;
 532
 533         bool result;
 534         overloadApply(ctor, (Dsymbol s)
 535         {
 536             if (auto td = s.isTemplateDeclaration())
 537             {
 538                 if (checkDisabled && td.onemember)
 539                 {
 540                     if (auto ctorDecl = td.onemember.isCtorDeclaration())
 541                     {
 542                         if (ctorDecl.storage_class & STC.disable)
 543                             return 0;
 544                     }
 545                 }
 546                 result = true;
 547                 return 1;
 548             }
 549             if (auto ctorDecl = s.isCtorDeclaration())
 550             {
 551                 if (!ctorDecl.isCpCtor && (!checkDisabled || !(ctorDecl.storage_class & STC.disable)))
 552                 {
 553                     result = true;
 554                     return 1;
 555                 }
 556             }
 557             return 0;
 558         });
 559         return result;
 560     }
 561 }
 562
 563 /**********************************
 564  * Determine if exp is all binary zeros.
 565  * Params:
 566  *      exp = expression to check
 567  * Returns:
 568  *      true if it's all binary 0
 569  */
 570 private bool _isZeroInit(Expression exp)
 571 {
 572     switch (exp.op)
 573     {
 574         case EXP.int64:
 575             return exp.toInteger() == 0;
 576
 577         case EXP.null_:
 578         case EXP.false_:
 579             return true;
 580
 581         case EXP.structLiteral:
 582         {
 583             auto sle = cast(StructLiteralExp) exp;
 584             foreach (i; 0 .. sle.sd.fields.length)
 585             {
 586                 auto field = sle.sd.fields[i];
 587                 if (field.type.size(field.loc))
 588                 {
 589                     auto e = (*sle.elements)[i];
 590                     if (e ? !_isZeroInit(e)
 591                           : !field.type.isZeroInit(field.loc))
 592                         return false;
 593                 }
 594             }
 595             return true;
 596         }
 597
 598         case EXP.arrayLiteral:
 599         {
 600             auto ale = cast(ArrayLiteralExp)exp;
 601
 602             const dim = ale.elements ? ale.elements.length : 0;
 603
 604             if (ale.type.toBasetype().ty == Tarray) // if initializing a dynamic array
 605                 return dim == 0;
 606
 607             foreach (i; 0 .. dim)
 608             {
 609                 if (!_isZeroInit(ale[i]))
 610                     return false;
 611             }
 612
 613             /* Note that true is returned for all T[0]
 614              */
 615             return true;
 616         }
 617
 618         case EXP.string_:
 619         {
 620             StringExp se = cast(StringExp)exp;
 621
 622             if (se.type.toBasetype().ty == Tarray) // if initializing a dynamic array
 623                 return se.len == 0;
 624
 625             foreach (i; 0 .. se.len)
 626             {
 627                 if (se.getCodeUnit(i))
 628                     return false;
 629             }
 630             return true;
 631         }
 632
 633         case EXP.vector:
 634         {
 635             auto ve = cast(VectorExp) exp;
 636             return _isZeroInit(ve.e1);
 637         }
 638
 639         case EXP.float64:
 640         case EXP.complex80:
 641         {
 642             import dmd.root.ctfloat : CTFloat;
 643             return (exp.toReal()      is CTFloat.zero) &&
 644                    (exp.toImaginary() is CTFloat.zero);
 645         }
 646
 647         default:
 648             return false;
 649     }
 650 }
 651
 652 /***********************************************************
 653  * Unions are a variation on structs.
 654  */
 655 extern (C++) final class UnionDeclaration : StructDeclaration
 656 {
 657     extern (D) this(const ref Loc loc, Identifier id)
 658     {
 659         super(loc, id, false);
 660     }
 661
 662     override UnionDeclaration syntaxCopy(Dsymbol s)
 663     {
 664         assert(!s);
 665         auto ud = new UnionDeclaration(loc, ident);
 666         StructDeclaration.syntaxCopy(ud);
 667         return ud;
 668     }
 669
 670     override const(char)* kind() const
 671     {
 672         return "union";
 673     }
 674
 675     override inout(UnionDeclaration) isUnionDeclaration() inout
 676     {
 677         return this;
 678     }
 679
 680     override void accept(Visitor v)
 681     {
 682         v.visit(this);
 683     }
 684 }