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