Refactor _d_arrayliteralTX (#21573)

Author: Albert24GG

compiler/src/dmd/backend/drtlsym.d

@@ -104,7 +104,6 @@ Symbol* getRtlsym(RTLSYM i) @trusted
         case RTLSYM.MEMSETSIMD:             symbolz(ps,FL.func,FREGSAVED,"_memsetSIMD",0, t); break;
         case RTLSYM.MEMSETN:                symbolz(ps,FL.func,FREGSAVED,"_memsetn",  0, t); break;
         case RTLSYM.NEWTHROW:               symbolz(ps,FL.func,FREGSAVED,"_d_newThrowable", 0, t); break;
-        case RTLSYM.ARRAYLITERALTX:         symbolz(ps,FL.func,FREGSAVED,"_d_arrayliteralTX", 0, t); break;
         case RTLSYM.ASSOCARRAYLITERALTX:    symbolz(ps,FL.func,FREGSAVED,"_d_assocarrayliteralTX", 0, t); break;
         case RTLSYM.CALLFINALIZER:          symbolz(ps,FL.func,FREGSAVED,"_d_callfinalizer", 0, t); break;
         case RTLSYM.CALLINTERFACEFINALIZER: symbolz(ps,FL.func,FREGSAVED,"_d_callinterfacefinalizer", 0, t); break;
@@ -158,7 +157,6 @@ Symbol* getRtlsym(RTLSYM i) @trusted
 
         case RTLSYM.TRACECALLFINALIZER:     symbolz(ps,FL.func,FREGSAVED,"_d_callfinalizerTrace", 0, t); break;
         case RTLSYM.TRACECALLINTERFACEFINALIZER: symbolz(ps,FL.func,FREGSAVED,"_d_callinterfacefinalizerTrace", 0, t); break;
-        case RTLSYM.TRACEARRAYLITERALTX:    symbolz(ps,FL.func,FREGSAVED,"_d_arrayliteralTXTrace", 0, t); break;
         case RTLSYM.TRACEASSOCARRAYLITERALTX: symbolz(ps,FL.func,FREGSAVED,"_d_assocarrayliteralTXTrace", 0, t); break;
         case RTLSYM.TRACEARRAYAPPENDCD:     symbolz(ps,FL.func,FREGSAVED,"_d_arrayappendcdTrace", 0, t); break;
         case RTLSYM.TRACEARRAYAPPENDWD:     symbolz(ps,FL.func,FREGSAVED,"_d_arrayappendwdTrace", 0, t); break;

compiler/src/dmd/backend/rtlsym.d

@@ -49,7 +49,6 @@ enum RTLSYM
     MEMSETN,
     NEWTHROW,
 
-    ARRAYLITERALTX,
     ASSOCARRAYLITERALTX,
     CALLFINALIZER,
     CALLINTERFACEFINALIZER,
@@ -102,7 +101,6 @@ enum RTLSYM
 
     TRACECALLFINALIZER,
     TRACECALLINTERFACEFINALIZER,
-    TRACEARRAYLITERALTX,
     TRACEASSOCARRAYLITERALTX,
     TRACEARRAYAPPENDCD,
     TRACEARRAYAPPENDWD,

compiler/src/dmd/dtemplate.d

@@ -4124,10 +4124,9 @@ extern (C++) class TemplateInstance : ScopeDsymbol
         * To bypass this edge case, we always do codegen for `_d_arrayliteralTX` template instances,
         * even if an instance already exists in non-root module.
         */
-        if (this.inst && this.inst.name == Id._d_arrayliteralTX)
-        {
-            return true;
-        }
+        if (auto inst = this.inst)
+            if (inst.name == Id._d_arrayliteralTX || inst.name == Id._d_arrayliteralTXTrace)
+                return true;
 
         if (global.params.allInst)
         {

compiler/src/dmd/e2ir.d

@@ -349,7 +349,6 @@ void toTraceGC(ref IRState irs, elem* e, Loc loc)
         [ RTLSYM.CALLFINALIZER, RTLSYM.TRACECALLFINALIZER ],
         [ RTLSYM.CALLINTERFACEFINALIZER, RTLSYM.TRACECALLINTERFACEFINALIZER ],
 
-        [ RTLSYM.ARRAYLITERALTX, RTLSYM.TRACEARRAYLITERALTX ],
         [ RTLSYM.ASSOCARRAYLITERALTX, RTLSYM.TRACEASSOCARRAYLITERALTX ],
 
 

compiler/src/dmd/nogc.d

@@ -164,7 +164,7 @@ public:
         lowering = new DotIdExp(e.loc, lowering, Id.object);
         auto tiargs = new Objects();
         // Remove `inout`, `const`, `immutable` and `shared` to reduce template instances
-        auto t = e.type.unqualify(MODFlags.wild | MODFlags.const_ | MODFlags.immutable_ | MODFlags.shared_);
+        auto t = e.type.nextOf().unqualify(MODFlags.wild | MODFlags.const_ | MODFlags.immutable_ | MODFlags.shared_);
         tiargs.push(t);
         lowering = new DotTemplateInstanceExp(e.loc, lowering, hook, tiargs);
 

compiler/test/compilable/extra-files/vcg-ast.d.cg

@@ -163,15 +163,96 @@ values!(__c_wchar_t)
 	}
 
 }
-_d_arrayliteralTX!(__c_wchar_t[])
+_d_arrayliteralTX!(__c_wchar_t)
 {
 	pure nothrow @trusted void* _d_arrayliteralTX(ulong length)
 	{
-		return _d_arrayliteralTX(typeid(__c_wchar_t[]), length);
+		const const(ulong) allocsize = length * 4LU;
+		if (allocsize == 0LU)
+			return null;
+		else
+		{
+			import core.memory : GC;
+			import core.internal.traits : hasIndirections, hasElaborateDestructor;
+			alias BlkAttr = BlkAttr;
+			uint attrs = 8u;
+			attrs |= BlkAttr.NO_SCAN;
+			return malloc(allocsize, attrs, typeid(__c_wchar_t));
+		}
 	}
 
 }
-static __gshared TypeInfo_Array _D28TypeInfo_AE3vcg11__c_wchar_t6__initZ;
+hasIndirections!(__c_wchar_t)
+{
+	enum bool hasIndirections = false;
+
+}
+OriginalType!(__c_wchar_t)
+{
+	alias OriginalType = dchar;
+
+}
+ModifyTypePreservingTQ!(Impl, __c_wchar_t)
+{
+	alias ModifyTypePreservingTQ = dchar;
+
+}
+Modifier!(__c_wchar_t)
+{
+	alias Impl = dchar;
+
+}
+OriginalType!dchar
+{
+	alias OriginalType = dchar;
+
+}
+ModifyTypePreservingTQ!(Impl, dchar)
+{
+	alias ModifyTypePreservingTQ = dchar;
+
+}
+Modifier!dchar
+{
+	alias Impl = dchar;
+
+}
+hasIndirections!dchar
+{
+	enum bool hasIndirections = false;
+
+}
+isFunctionPointer!dchar
+{
+	enum bool isFunctionPointer = false;
+
+}
+isPointer!dchar
+{
+	enum bool isPointer = false;
+
+}
+isAggregateType!dchar
+{
+	enum bool isAggregateType = false;
+
+}
+isDelegate!dchar
+{
+	enum bool isDelegate = false;
+
+}
+isDynamicArray!dchar
+{
+	enum bool isDynamicArray = false;
+
+}
+Unqual!(dchar, dchar)
+{
+	alias Unqual = dchar;
+
+}
+static __gshared TypeInfo_Enum _D27TypeInfo_E3vcg11__c_wchar_t6__initZ;
 RTInfo!(_R)
 {
 	enum immutable(void)* RTInfo = null;

druntime/src/core/internal/array/construction.d

@@ -589,11 +589,53 @@ version (D_ProfileGC)
     }
 }
 
-extern (C) void* _d_arrayliteralTX(const TypeInfo ti, size_t length) @trusted pure nothrow;
 
+/**
+Allocate an array literal
+
+Rely on the caller to do the initialization of the array.
+
+---
+int[] getArr()
+{
+    return [10, 20];
+    // auto res = cast(int*) _d_arrayliteralTX(typeid(int[]), 2);
+    // res[0] = 10;
+    // res[1] = 20;
+    // return res[0..2];
+}
+---
+
+Params:
+    T = unqualified type of array elements
+    length = `.length` of array literal
+
+Returns: pointer to allocated array
+*/
 void* _d_arrayliteralTX(T)(size_t length) @trusted pure nothrow
 {
-    return _d_arrayliteralTX(typeid(T), length);
+    const allocsize = length * T.sizeof;
+
+    if (allocsize == 0)
+        return null;
+    else
+    {
+        import core.memory : GC;
+        import core.internal.traits : hasIndirections, hasElaborateDestructor;
+        alias BlkAttr = GC.BlkAttr;
+
+        /* Same as in core.internal.array.utils.__typeAttrs!T,
+        *  but don't use a nested template function call here to avoid
+        *  possible linking errors.
+        */
+        uint attrs = BlkAttr.APPENDABLE;
+        static if (!hasIndirections!T)
+            attrs |= BlkAttr.NO_SCAN;
+        static if (is(T == struct) && hasElaborateDestructor!T)
+            attrs |= BlkAttr.FINALIZE;
+
+        return GC.malloc(allocsize, attrs, typeid(T));
+    }
 }
 
 version (D_ProfileGC)
@@ -602,7 +644,7 @@ void* _d_arrayliteralTXTrace(T)(size_t length, string file = __FILE__, int line
     version (D_TypeInfo)
     {
         import core.internal.array.utils : TraceHook, gcStatsPure, accumulatePure;
-        mixin(TraceHook!(T.stringof, "_d_arrayliteralTX"));
+        mixin(TraceHook!((T[]).stringof, "_d_arrayliteralTX"));
 
         return _d_arrayliteralTX!T(length);
     }

druntime/src/rt/lifetime.d

@@ -695,45 +695,6 @@ extern (C) void[] _d_arrayappendwd(ref byte[] x, dchar c) @weak
     return x;
 }
 
-/**
-Allocate an array literal
-
-Rely on the caller to do the initialization of the array.
-
----
-int[] getArr()
-{
-    return [10, 20];
-    // auto res = cast(int*) _d_arrayliteralTX(typeid(int[]), 2);
-    // res[0] = 10;
-    // res[1] = 20;
-    // return res[0..2];
-}
----
-
-Params:
-    ti = `TypeInfo` of resulting array type
-    length = `.length` of array literal
-
-Returns: pointer to allocated array
-*/
-extern (C)
-void* _d_arrayliteralTX(const TypeInfo ti, size_t length) @weak
-{
-    auto tinext = unqualify(ti.next);
-    auto sizeelem = tinext.tsize;              // array element size
-    void* result;
-
-    debug(PRINTF) printf("_d_arrayliteralTX(sizeelem = %zd, length = %zd)\n", sizeelem, length);
-    if (length == 0 || sizeelem == 0)
-        return null;
-    else
-    {
-        auto allocsize = length * sizeelem;
-        return GC.malloc(allocsize, __typeAttrs(tinext) | BlkAttr.APPENDABLE, tinext);
-    }
-}
-
 
 unittest
 {

druntime/src/rt/tracegc.d

@@ -20,7 +20,6 @@ extern (C) void _d_callinterfacefinalizer(void *p);
 extern (C) void _d_delclass(Object* p);
 extern (C) void _d_delinterface(void** p);
 extern (C) void _d_delmemory(void* *p);
-extern (C) void* _d_arrayliteralTX(const TypeInfo ti, size_t length);
 extern (C) void* _d_assocarrayliteralTX(const TypeInfo_AssociativeArray ti,
     void[] keys, void[] vals);
 extern (C) void[] _d_arrayappendcd(ref byte[] x, dchar c);