Implement section attribute

Author: rikkimax

compiler/src/dmd/declaration.d

@@ -433,6 +433,8 @@ extern (C++) class VarDeclaration : Declaration
     Expression edtor;               // if !=null, does the destruction of the variable
     IntRange* range;                // if !=null, the variable is known to be within the range
 
+    string userDefinedSection;      // the @section("name"), if present
+
     uint endlinnum;                 // line number of end of scope that this var lives in
     uint offset;
     uint sequenceNumber;            // order the variables are declared

compiler/src/dmd/declaration.h

@@ -237,6 +237,8 @@ class VarDeclaration : public Declaration
     Expression *edtor;          // if !=NULL, does the destruction of the variable
     IntRange *range;            // if !NULL, the variable is known to be within the range
 
+    DString userDefinedSection;
+
     unsigned endlinnum;         // line number of end of scope that this var lives in
     unsigned offset;
     unsigned sequenceNumber;     // order the variables are declared

compiler/src/dmd/dsymbolsem.d

@@ -3154,6 +3154,31 @@ private extern(C++) final class DsymbolSemanticVisitor : Visitor
             }
         }
 
+        // find the @section("name") uda
+        foreachUda(dsym, sc, (e) {
+            if (!e.isStructLiteralExp())
+                return 0;
+
+            auto literal = e.isStructLiteralExp();
+            assert(literal.sd);
+
+            if (!isCoreUda(literal.sd, Id.udaSection))
+                return 0;
+
+            if (dsym.userDefinedSection)
+            {
+                .error(dsym.loc, "%s `%s` can only have one section attribute", dsym.kind, dsym.toPrettyChars);
+                return 1;
+            }
+
+            assert(literal.elements.length == 1);
+            auto se = (*literal.elements)[0].toStringExp();
+            assert(se);
+
+            dsym.userDefinedSection = cast(string)se.toUTF8(sc).toStringz();
+            return 0;
+        });
+
         dsym.semanticRun = PASS.semanticdone;
 
         if (dsym.type.toBasetype().ty == Terror)

compiler/src/dmd/frontend.h

@@ -6598,6 +6598,7 @@ class VarDeclaration : public Declaration
     VarDeclaration* lastVar;
     Expression* edtor;
     IntRange* range;
+    _d_dynamicArray< const char > userDefinedSection;
     uint32_t endlinnum;
     uint32_t offset;
     uint32_t sequenceNumber;
@@ -8881,6 +8882,7 @@ struct Id final
     static Identifier* udaOptional;
     static Identifier* udaMustUse;
     static Identifier* udaStandalone;
+    static Identifier* udaSection;
     static Identifier* TRUE;
     static Identifier* FALSE;
     static Identifier* ImportC;

compiler/src/dmd/glue/toobj.d

@@ -485,6 +485,62 @@ void toObjFile(Dsymbol ds, bool multiobj)
             Dsymbol parent = vd.toParent();
             s.Sclass = SC.global;
 
+            if (auto sectionName = vd.userDefinedSection)
+            {
+                import core.bitop;
+                const canBeReadOnly = !(vd.type.isTypeClass || vd.type.isMutable);
+
+                // The following alignment calculations looks complex, but its actually pretty simple.
+                // Given either alignment of for the type of the variable, ensure that it is a power of 2 (round up).
+                // Linkers don't like it when it isn't a power of 2.
+                const alignToRequested = vd.type.alignsize();
+                const alignToPower = alignToRequested > 0 ? bsr(alignToRequested) : 0;
+                const alignToActual = (1 << alignToPower) == alignToRequested ? alignToRequested : (1 << (alignToPower + 1));
+
+                switch (config.objfmt)
+                {
+                    case OBJ_MACH:
+                        import dmd.backend.mach;
+
+                        s.Sseg = Obj.getsegment(
+                            sectionName.ptr,
+                            canBeReadOnly ? "__TEXT" : "__DATA",
+                            bsr(alignToActual),
+                            S_REGULAR // flags
+                        );
+                        break;
+                    case OBJ_ELF:
+                        import dmd.backend.elfobj;
+                        import dmd.backend.melf;
+
+                        s.Sseg = Obj.getsegment(
+                            sectionName.ptr,
+                            null, // suffix
+                            SHT_PROGBITS, // type
+                            SHF_ALLOC | (canBeReadOnly ? 0 : SHF_WRITE), // flags
+                            alignToActual // align
+                        );
+                        break;
+                    case OBJ_MSCOFF:
+                        import dmd.backend.mscoff;
+
+                        const alignTo2 = IMAGE_SCN_ALIGN_1BYTES << (alignToActual > 0 ? bsr(alignToActual) : 0);
+                        const alignTo3 = alignTo2 <= IMAGE_SCN_ALIGN_8192BYTES ? alignTo2 : IMAGE_SCN_ALIGN_8192BYTES;
+
+                        s.Sseg = Obj.getsegment(
+                            sectionName.ptr,
+                            // flags
+                            alignTo3
+                            | IMAGE_SCN_MEM_READ
+                            | IMAGE_SCN_CNT_INITIALIZED_DATA
+                            | (canBeReadOnly ? 0 : IMAGE_SCN_MEM_WRITE)
+                        );
+                        break;
+                    default:
+                        break;
+                }
+            }
+
             /* Make C static functions SCstatic
              */
             if (vd.storage_class & STC.static_ && vd.isCsymbol())

compiler/src/dmd/id.d

@@ -500,6 +500,7 @@ immutable Msgtable[] msgtable =
     { "udaOptional", "optional"},
     { "udaMustUse", "mustuse" },
     { "udaStandalone", "standalone" },
+    { "udaSection", "section" },
 
     // Editions
     { "__edition_latest_do_not_use", },

compiler/test/runnable/extra-files/sectiondefs.d

@@ -0,0 +1,8 @@
+module extrafiles.sectiondefs;
+import core.attribute;
+
+@section("myInts")
+__gshared int anInt = 9;
+
+@section("my8Ints")
+__gshared int[8] an8Int = [64, 72, 9, 81, 21, 59, 45, 2];

compiler/test/runnable/sectiondefs.d

@@ -0,0 +1,77 @@
+/*
+EXTRA_SOURCES: extra-files/sectiondefs.d
+EXTRA_FILES: extra-files/sectiondefs.d
+*/
+module sectiondefs;
+import core.attribute;
+
+version (linux)
+    version = ELF;
+else version (FreeBSD)
+    version = ELF;
+else version (OpenBSD)
+    version = ELF;
+else version (NetBSD)
+    version = ELF;
+
+mixin template SectionRange(string SectionName, Type)
+{
+    version (OSX)
+    {
+        pragma(mangle, "section$start$__TEXT$" ~ SectionName) extern (C) extern __gshared Type start;
+
+        pragma(mangle, "section$end$__TEXT$" ~ SectionName) extern (C) extern __gshared Type end;
+    }
+    else version (ELF)
+    {
+        pragma(mangle, "__start_" ~ SectionName) extern (C) extern __gshared Type start;
+
+        pragma(mangle, "__stop_" ~ SectionName) extern (C) extern __gshared Type end;
+    }
+    else version (Windows)
+    {
+        @section(SectionName ~ "$A")
+        immutable byte _head = 0;
+
+        @section(SectionName ~ "$Z")
+        immutable byte _tail = 0;
+
+        Type* start()
+        {
+            return cast(Type*)(cast(byte*)&_head + 1);
+        }
+
+        Type* end()
+        {
+            return cast(Type*)&_tail;
+        }
+    }
+
+    Type[] range()
+    {
+        version (Windows)
+            return start()[0 .. end() - start()];
+        else
+            return (&start)[0 .. (&end - &start)];
+    }
+}
+
+mixin SectionRange!("myInts", int) myIntsSection;
+mixin SectionRange!("my8Ints", int[8]) my8IntsSection;
+
+@section("myInts")
+__gshared int anInt = 2;
+
+@section("my8Ints")
+__gshared int[8] an8Int = [46, 92, 11, 7, 2, 55, 33, 22];
+
+void main()
+{
+    assert(myIntsSection.range == [2, 9] || myIntsSection.range == [9, 2]);
+
+    assert(my8IntsSection.range == [
+        [46, 92, 11, 7, 2, 55, 33, 22], [64, 72, 9, 81, 21, 59, 45, 2]
+    ] || my8IntsSection.range == [
+        [64, 72, 9, 81, 21, 59, 45, 2], [46, 92, 11, 7, 2, 55, 33, 22]
+    ]);
+}

druntime/src/core/attribute.d

@@ -83,6 +83,32 @@ else
     // GDC and LDC declare this attribute in their own modules.
 }
 
+version(DigitalMars)
+{
+    /**
+    * When applied to a global variable, causes it to be emitted to a
+    * non-standard object file/executable section.
+    *
+    * The target platform might impose certain restrictions on the format for
+    * section names.
+    *
+    * Examples:
+    * ---
+    * import core.attributes;
+    *
+    * @section("mySection") int myGlobal;
+    * ---
+    */
+    struct section
+    {
+        string name;
+    }
+}
+else
+{
+    // GDC and LDC declare this attribute in their own modules.
+}
+
 /**
  * Use this attribute to attach an Objective-C selector to a method.
  *