Upgrade frontend & libs to v2.108

.github/workflows/main.yml

@@ -74,7 +74,7 @@ jobs:
 
     name: ${{ matrix.job_name }}
     runs-on: ${{ matrix.os }}
-    timeout-minutes: 150
+    timeout-minutes: 90
     env:
       MACOSX_DEPLOYMENT_TARGET: 10.12
     steps:

.github/workflows/supported_llvm_versions.yml

@@ -41,7 +41,7 @@ jobs:
             cmake_flags: -DRT_SUPPORT_SANITIZERS=ON
           - job_name: Ubuntu 20.04, LLVM 12, bootstrap LDC
             os: ubuntu-20.04
-            host_dc: ldc-1.9.0
+            host_dc: ldc-1.19.0
             llvm_version: 12.0.1
             cmake_flags: -DBUILD_SHARED_LIBS=ON -DLIB_SUFFIX=64
           - job_name: Ubuntu 20.04, LLVM 11, latest DMD beta

CHANGELOG.md

@@ -1,6 +1,7 @@
 # LDC master
 
 #### Big news
+- Frontend, druntime and Phobos are at version [2.108.0](https://dlang.org/changelog/2.108.0.html). (#4591)
 
 #### Platform support
 

CMakeLists.txt

@@ -117,10 +117,10 @@ include(GetLinuxDistribution)
 #
 
 # Version information
-set(LDC_VERSION "1.37.0") # May be overridden by git hash tag
+set(LDC_VERSION "1.38.0") # May be overridden by git hash tag
 set(DMDFE_MAJOR_VERSION   2)
-set(DMDFE_MINOR_VERSION   107)
-set(DMDFE_PATCH_VERSION   1)
+set(DMDFE_MINOR_VERSION   108)
+set(DMDFE_PATCH_VERSION   0)
 
 set(DMD_VERSION ${DMDFE_MAJOR_VERSION}.${DMDFE_MINOR_VERSION}.${DMDFE_PATCH_VERSION})
 

dmd/README.md

@@ -110,13 +110,17 @@ Note that these groups have no strict meaning, the category assignments are a bi
 | File                                                                                      | Purpose                                                           |
 |-------------------------------------------------------------------------------------------|-------------------------------------------------------------------|
 | [dsymbolsem.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/dsymbolsem.d)             | Do semantic 1 pass (symbol identifiers/types)                     |
+| [enumsem.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/enumsem.d)                   | Enum semantics                                                    |
+| [funcsem.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/funcsem.d)                   | Function semantics                                                |
 | [semantic2.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/semantic2.d)               | Do semantic 2 pass (symbol initializers)                          |
 | [semantic3.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/semantic3.d)               | Do semantic 3 pass (function bodies)                              |
 | [inline.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/inline.d)                     | Do inline pass (optimization pass that dmd does in the front-end) |
 | [inlinecost.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/inlinecost.d)             | Compute the cost of inlining a function call.                     |
 | [expressionsem.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/expressionsem.d)       | Do semantic analysis for expressions                              |
 | [statementsem.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/statementsem.d)         | Do semantic analysis for statements                               |
 | [initsem.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/initsem.d)                   | Do semantic analysis for initializers                             |
+| [pragmasem.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/pragmasem.d)               | Do semantic analysis for pragmas                                  |
+| [templatesem.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/templatesem.d)           | Do semantic analysis for templates                                |
 | [templateparamsem.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/templateparamsem.d) | Do semantic analysis for template parameters                      |
 | [typesem.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/typesem.d)                   | Do semantic analysis for types                                    |
 
@@ -230,6 +234,7 @@ Note that these groups have no strict meaning, the category assignments are a bi
 |-----------------------------------------------------------------------------------|------------------------------------------------------------------|
 | [cppmangle.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/cppmangle.d)       | C++ name mangling                                                |
 | [cppmanglewin.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/cppmanglewin.d) | C++ name mangling for Windows                                    |
+| [basicmangle.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/basicmangle.d)   | D name mangling for basic types                                  |
 | [dmangle.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/dmangle.d)           | D [name mangling](https://dlang.org/spec/abi.html#name_mangling) |
 
 ### Linking

dmd/aggregate.d

@@ -37,7 +37,7 @@ import dmd.identifier;
 import dmd.location;
 import dmd.mtype;
 import dmd.tokens;
-import dmd.typesem : defaultInit;
+import dmd.typesem : defaultInit, addMod;
 import dmd.visitor;
 
 /**

dmd/aggregate.h

@@ -41,7 +41,11 @@ enum class Baseok : uint8_t
     semanticdone  // all base classes semantic done
 };
 
-FuncDeclaration *search_toString(StructDeclaration *sd);
+namespace dmd
+{
+    FuncDeclaration *search_toString(StructDeclaration *sd);
+    void semanticTypeInfoMembers(StructDeclaration *sd);
+}
 
 enum class ClassKind : uint8_t
 {
@@ -238,7 +242,8 @@ struct ClassFlags
         hasTypeInfo = 0x20,
         isAbstract = 0x40,
         isCPPclass = 0x80,
-        hasDtor = 0x100
+        hasDtor = 0x100,
+        hasNameSig = 0x200,
     };
 };
 

dmd/argtypes.h

@@ -0,0 +1,25 @@
+
+/* Compiler implementation of the D programming language
+ * Copyright (C) 1999-2024 by The D Language Foundation, All Rights Reserved
+ * written by Walter Bright
+ * https://www.digitalmars.com
+ * Distributed under the Boost Software License, Version 1.0.
+ * https://www.boost.org/LICENSE_1_0.txt
+ * https://github.com/dlang/dmd/blob/master/compiler/src/dmd/argtypes.h
+ */
+
+#pragma once
+
+class Type;
+class TypeTuple;
+
+namespace dmd
+{
+    // in argtypes_x86.d
+    TypeTuple *toArgTypes_x86(Type *t);
+    // in argtypes_sysv_x64.d
+    TypeTuple *toArgTypes_sysv_x64(Type *t);
+    // in argtypes_aarch64.d
+    TypeTuple *toArgTypes_aarch64(Type *t);
+    bool isHFVA(Type *t, int maxNumElements = 4, Type **rewriteType = nullptr);
+}

dmd/argtypes_aarch64.d

@@ -27,7 +27,7 @@ import dmd.mtype;
  *      A tuple of zero length means the type cannot be passed/returned in registers.
  *      null indicates a `void`.
  */
-extern (C++) TypeTuple toArgTypes_aarch64(Type t)
+TypeTuple toArgTypes_aarch64(Type t)
 {
     if (t == Type.terror)
         return new TypeTuple(t);
@@ -64,7 +64,9 @@ extern (C++) TypeTuple toArgTypes_aarch64(Type t)
         case 2:  return Type.tint16;
         case 4:  return Type.tint32;
         case 8:  return Type.tint64;
-        default: return Type.tint64.sarrayOf((size + 7) / 8);
+        default:
+            import dmd.typesem : sarrayOf;
+            return Type.tint64.sarrayOf((size + 7) / 8);
         }
     }
     return new TypeTuple(getGPType(size));
@@ -82,7 +84,7 @@ extern (C++) TypeTuple toArgTypes_aarch64(Type t)
  * If the type is an HFVA and `rewriteType` is specified, it is set to a
  * corresponding static array type.
  */
-extern (C++) bool isHFVA(Type t, int maxNumElements = 4, Type* rewriteType = null)
+bool isHFVA(Type t, int maxNumElements = 4, Type* rewriteType = null)
 {
     t = t.toBasetype();
     if ((t.ty != Tstruct && t.ty != Tsarray && !t.iscomplex()) || !isPOD(t))
@@ -93,6 +95,7 @@ extern (C++) bool isHFVA(Type t, int maxNumElements = 4, Type* rewriteType = nul
     if (N < 1 || N > maxNumElements)
         return false;
 
+    import dmd.typesem : sarrayOf;
     if (rewriteType)
         *rewriteType = fundamentalType.sarrayOf(N);
 

dmd/argtypes_sysv_x64.d

@@ -30,7 +30,7 @@ import dmd.visitor;
  *      A tuple of zero length means the type cannot be passed/returned in registers.
  *      null indicates a `void`.
  */
-extern (C++) TypeTuple toArgTypes_sysv_x64(Type t)
+TypeTuple toArgTypes_sysv_x64(Type t)
 {
     if (t == Type.terror)
         return new TypeTuple(t);
@@ -65,6 +65,7 @@ extern (C++) TypeTuple toArgTypes_sysv_x64(Type t)
             assert(c == Class.sseUp);
 
         assert(size % 8 == 0);
+        import dmd.typesem : sarrayOf;
         return new TypeTuple(new TypeVector(Type.tfloat64.sarrayOf(N)));
     }
 

dmd/argtypes_x86.d

@@ -33,7 +33,7 @@ import dmd.visitor;
  *      A tuple of zero length means the type cannot be passed/returned in registers.
  *      null indicates a `void`.
  */
-extern (C++) TypeTuple toArgTypes_x86(Type t)
+TypeTuple toArgTypes_x86(Type t)
 {
     extern (C++) final class ToArgTypes : Visitor
     {

dmd/arrayop.d

@@ -22,7 +22,7 @@ import dmd.dsymbol;
 import dmd.errors;
 import dmd.expression;
 import dmd.expressionsem;
-import dmd.func;
+import dmd.funcsem;
 import dmd.hdrgen;
 import dmd.id;
 import dmd.identifier;

dmd/ast_node.h

@@ -10,7 +10,7 @@
 
 #pragma once
 
-#include "root/object.h"
+#include "rootobject.h"
 
 class Visitor;
 

dmd/astcodegen.d

@@ -82,6 +82,7 @@ struct ASTCodegen
     alias Tcomplex64                = dmd.mtype.Tcomplex64;
     alias Tcomplex80                = dmd.mtype.Tcomplex80;
 
+    alias ModToStc                  = dmd.mtype.ModToStc;
     alias ParameterList             = dmd.mtype.ParameterList;
     alias VarArg                    = dmd.mtype.VarArg;
     alias STC                       = dmd.declaration.STC;

dmd/astenums.d

@@ -152,7 +152,7 @@ bool isRefReturnScope(const ulong stc)
 
 /* This is different from the one in declaration.d, make that fix a separate PR */
 static if (0)
-extern (C++) __gshared const(StorageClass) STCStorageClass =
+__gshared const(StorageClass) STCStorageClass =
     (STC.auto_ | STC.scope_ | STC.static_ | STC.extern_ | STC.const_ | STC.final_ |
      STC.abstract_ | STC.synchronized_ | STC.deprecated_ | STC.override_ | STC.lazy_ |
      STC.alias_ | STC.out_ | STC.in_ | STC.manifest | STC.immutable_ | STC.shared_ |
@@ -459,3 +459,9 @@ extern (C++) struct structalign_t
     bool isPack() const    { return pack; }
     void setPack(bool pack) { this.pack = pack; }
 }
+
+/// Use to return D arrays from C++ functions
+extern (C++) struct DArray(T)
+{
+    T[] data;
+}

dmd/basicmangle.d

@@ -0,0 +1,109 @@
+/**
+ * Defines the building blocks for creating the mangled names for basic types.
+ *
+ * Copyright:   Copyright (C) 1999-2024 by The D Language Foundation, All Rights Reserved
+ * License:     $(LINK2 https://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
+ * Source:      $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/basicmangle.d, _basicmangle.d)
+ * Documentation:  https://dlang.org/phobos/dmd_basicmangle.html
+ * Coverage:    https://codecov.io/gh/dlang/dmd/src/master/src/dmd/basicmangle.d
+ */
+module dmd.basicmangle;
+
+import dmd.astenums;
+import dmd.common.outbuffer : OutBuffer;
+
+/// Type mangling mapping for basic, derived and user defined types
+immutable char[TMAX] mangleChar =
+[
+    Tchar        : 'a',
+    Tbool        : 'b',
+    Tcomplex80   : 'c',
+    Tfloat64     : 'd',
+    Tfloat80     : 'e',
+    Tfloat32     : 'f',
+    Tint8        : 'g',
+    Tuns8        : 'h',
+    Tint32       : 'i',
+    Timaginary80 : 'j',
+    Tuns32       : 'k',
+    Tint64       : 'l',
+    Tuns64       : 'm',
+    Tnull        : 'n',
+    Timaginary32 : 'o',
+    Timaginary64 : 'p',
+    Tcomplex32   : 'q',
+    Tcomplex64   : 'r',
+    Tint16       : 's',
+    Tuns16       : 't',
+    Twchar       : 'u',
+    Tvoid        : 'v',
+    Tdchar       : 'w',
+    //              x   // const
+    //              y   // immutable
+    Tint128      : 'z', // zi
+    Tuns128      : 'z', // zk
+
+    Tarray       : 'A',
+    Ttuple       : 'B',
+    Tclass       : 'C',
+    Tdelegate    : 'D',
+    Tenum        : 'E',
+    Tfunction    : 'F', // D function
+    Tsarray      : 'G',
+    Taarray      : 'H',
+    //              I   // in
+    //              J   // out
+    //              K   // ref
+    //              L   // lazy
+    //              M   // has this, or scope
+    //              N   // Nh:vector Ng:wild Nn:noreturn
+    //              O   // shared
+    Tpointer     : 'P',
+    //              Q   // Type/symbol/identifier backward reference
+    Treference   : 'R',
+    Tstruct      : 'S',
+    //              T   // Ttypedef
+    //              U   // C function
+    //              W   // Windows function
+    //              X   // variadic T t...)
+    //              Y   // variadic T t,...)
+    //              Z   // not variadic, end of parameters
+
+    // '@' shouldn't appear anywhere in the deco'd names
+    Tnone        : '@',
+    Tident       : '@',
+    Tinstance    : '@',
+    Terror       : '@',
+    Ttypeof      : '@',
+    Tslice       : '@',
+    Treturn      : '@',
+    Tvector      : '@',
+    Ttraits      : '@',
+    Tmixin       : '@',
+    Ttag         : '@',
+    Tnoreturn    : '@',         // becomes 'Nn'
+];
+
+unittest
+{
+    foreach (i, mangle; mangleChar)
+    {
+        if (mangle == char.init)
+        {
+            import core.stdc.stdio;
+            fprintf(stderr, "ty = %u\n", cast(uint)i);
+            assert(0);
+        }
+    }
+}
+
+/***********************
+ * Mangle basic type ty to buf.
+ */
+void tyToDecoBuffer(ref OutBuffer buf, int ty) @safe
+{
+    const c = mangleChar[ty];
+    buf.writeByte(c);
+    if (c == 'z')
+        buf.writeByte(ty == Tint128 ? 'i' : 'k');
+}

dmd/cli.d

@@ -423,22 +423,21 @@ dmd -cov -unittest myprog.d
         Option("Hf=<filename>",
             "write 'header' file to filename"
         ),
-        Option("HC[=[silent|verbose]]",
-            "generate C++ 'header' file",
-            `Generate C++ 'header' files using the given configuration:",
+        Option("HC[=[?|h|help|silent|verbose]]",
+            "write C++ 'header' equivalent to stdout",
+            `write C++ 'header' equivalent to stdout configured with:",
             $(DL
+            $(DT ?|h|help)$(DD list available options for C++ 'header' file generation)
             $(DT silent)$(DD only list extern(C[++]) declarations (default))
             $(DT verbose)$(DD also add comments for ignored declarations (e.g. extern(D)))
             )`,
         ),
-        Option("HC=[?|h|help]",
-            "list available modes for C++ 'header' file generation"
-        ),
         Option("HCd=<directory>",
-            "write C++ 'header' file to directory"
+            "write C++ 'header' file to directory",
+            "write C++ 'header' file to directory, ignored if -HCf=<filename> is not present",
         ),
         Option("HCf=<filename>",
-            "write C++ 'header' file to filename"
+            "write C++ 'header' file to filename instead of stdout"
         ),
         Option("-help",
             "print help and exit"