backend: remove more C++ declarations (dlang#23156)

* Remove unused cpp RTLSYM, func_t fields, and pef_flags_t

* backend: remove more unused C++ types

* Remove CPP condition

* backend: remove C++ func_flags/storage classes remnants

Author: dkorpel

compiler/src/dmd/backend/arm/cod2.d

@@ -894,22 +894,7 @@ void cdcond(ref CGstate cg, ref CodeBuilder cdb,elem* e,ref regm_t pretregs)
     else
         codelem(cg,cdb1,e21,retregs,false);
 
-    if (CPP && e2.Eoper == OPcolon2)
-    {
-        code cs;
-
-        // This is necessary so that any cleanup code on one branch
-        // is redone on the other branch.
-        cs.Iop = PSOP.mark2;
-        cs.Iflags = 0;
-        cs.Irex = 0;
-        cdb.gen(&cs);
-        cdb.append(cdb1);
-        cs.Iop = PSOP.release2;
-        cdb.gen(&cs);
-    }
-    else
-        cdb.append(cdb1);
+    cdb.append(cdb1);
 
     const regconsave = cg.regcon;
     cg.regcon = cast()regconold;

compiler/src/dmd/backend/cc.d

@@ -52,9 +52,6 @@ alias enum_TK = ubyte;
 
 __gshared Config config;
 
-@trusted
-uint CPP() { return config.flags3 & CFG3cpp; }
-
 
 /////////// Position in source file
 
@@ -408,50 +405,27 @@ enum
 {
     Fpending    = 1,           // if function has been queued for being written
     Foutput     = 2,           // if function has been written out
-    Foperator   = 4,           // if operator overload
-    Fcast       = 8,           // if cast overload
     Finline     = 0x10,        // if SCinline, and function really is inline
-    Foverload   = 0x20,        // if function can be overloaded
-    Ftypesafe   = 0x40,        // if function name needs type appended
-    Fmustoutput = 0x80,        // set for forward ref'd functions that
-                               // must be output
-    Fvirtual    = 0x100,       // if function is a virtual function
     Fctor       = 0x200,       // if function is a constructor
     Fdtor       = 0x400,       // if function is a destructor
-    Fnotparent  = 0x800,       // if function is down Foversym chain
     Finlinenest = 0x1000,      // used as a marker to prevent nested
                                // inlines from expanding
-    Flinkage    = 0x2000,      // linkage is already specified
     Fstatic     = 0x4000,      // static member function (no this)
-    Fbitcopy    = 0x8000,      // it's a simple bitcopy (op=() or X(X&))
     Fpure       = 0x10000,     // pure function
-    Finstance   = 0x20000,     // function is an instance of a template
-    Ffixed      = 0x40000,     // ctor has had cpp_fixconstructor() run on it,
-                               // dtor has had cpp_fixdestructor()
-    Fintro      = 0x80000,     // function doesn't hide a previous virtual function
-//  unused      = 0x100000,    // unused bit
-    Fkeeplink   = 0x200000,    // don't change linkage to default
-    Fnodebug    = 0x400000,    // do not generate debug info for this function
-    Fgen        = 0x800000,    // compiler generated function
     Finvariant  = 0x1000000,   // __invariant function
-    Fexplicit   = 0x2000000,   // explicit constructor
-    Fsurrogate  = 0x4000000,   // surrogate call function
 }
 
 alias func_flags3_t = uint;
 enum
 {
     Fvtblgen         = 1,       // generate vtbl[] when this function is defined
-    Femptyexc        = 2,       // empty exception specification (obsolete, use Tflags & TFemptyexc)
     Fcppeh           = 4,       // uses C++ EH
     Fnteh            = 8,       // uses NT Structured EH
-    Fdeclared        = 0x10,    // already declared function Symbol
     Fmark            = 0x20,    // has unbalanced OPctor's
     Fdoinline        = 0x40,    // do inline walk
     Foverridden      = 0x80,    // ignore for overriding purposes
     Fjmonitor        = 0x100,   // Mars synchronized function
     Fnosideeff       = 0x200,   // function has no side effects
-    F3badoparrow     = 0x400,   // bad operator->()
     Fmain            = 0x800,   // function is D main
     Fnested          = 0x1000,  // D nested function with 'this'
     Fmember          = 0x2000,  // D member function with 'this'
@@ -473,38 +447,11 @@ struct func_t
     Symbol* F__func__;          // symbol for __func__[] string
     func_flags_t Fflags;
     func_flags3_t Fflags3;
-    ubyte Foper;                // operator number (OPxxxx) if Foperator
-
-    Symbol* Fparsescope;        // use this scope to parse friend functions
-                                // which are defined within a class, so the
-                                // class is in scope, but are not members
-                                // of the class
 
     Classsym* Fclass;           // if member of a class, this is the class
                                 // (I think this is redundant with Sscope)
-    Funcsym* Foversym;          // overloaded function at same scope
-    symlist_t Fclassfriends;    // Symbol list of classes of which this
-                                // function is a friend
-    block* Fbaseblock;          // block where base initializers get attached
-    block* Fbaseendblock;       // block where member destructors get attached
-    elem* Fbaseinit;            // list of member initializers (meminit_t)
-                                // this field has meaning only for
-                                // functions which are constructors
-    uint Fsequence;             // sequence number at point of definition
-    Symbol* Ftempl;         // if Finstance this is the template that generated it
     Funcsym* Falias;            // SCfuncalias: function Symbol referenced
                                 // by using-declaration
-    symlist_t Fthunks;          // list of thunks off of this function
-    param_t* Farglist;          // SCfunctempl: the template-parameter-list
-    param_t* Fptal;             // Finstance: this is the template-argument-list
-                                // SCftexpspec: for explicit specialization, this
-                                // is the template-argument-list
-    list_t Ffwdrefinstances;    // SCfunctempl: list of forward referenced instances
-    list_t Fexcspec;            // List of types in the exception-specification
-                                // (NULL if none or empty)
-    Funcsym* Fexplicitspec;     // SCfunctempl, SCftexpspec: threaded list
-                                // of SCftexpspec explicit specializations
-    Funcsym* Fsurrogatesym;     // Fsurrogate: surrogate cast function
 
     char* Fredirect;            // redirect function name to this name in object
 
@@ -527,17 +474,8 @@ struct baseclass_t
     Classsym*         BCbase;           // base class Symbol
     baseclass_t*      BCnext;           // next base class
     targ_size_t       BCoffset;         // offset from start of derived class to this
-    ushort            BCvbtbloff;       // for BCFvirtual, offset from start of
-                                        //     vbtbl[] to entry for this virtual base.
-                                        //     Valid in Sbase list
-    symlist_t         BCpublics;        // public members of base class (list is freeable)
-    list_t            BCmptrlist;       // (in Smptrbase only) this is the vtbl
-                                        // (NULL if not different from base class's vtbl
     Symbol*           BCvtbl;           // Symbol for vtbl[] array (in Smptrbase list)
                                         // Symbol for vbtbl[] array (in Svbptrbase list)
-    Classsym*         BCparent;         // immediate parent of this base class
-                                        //     in Smptrbase
-    baseclass_t*      BCpbase;          // parent base, NULL if did not come from a parent
 }
 
 /***********************************
@@ -572,26 +510,9 @@ enum
     STRnotagname     = 4,          // struct/class with no tag name
     STRoutdef        = 8,          // we've output the debug definition
     STRbitfields     = 0x10,       // set if struct contains bit fields
-    STRabstract      = 0x20,       // abstract class
-    STRbitcopy       = 0x40,       // set if operator=() is merely a bit copy
-    STRanyctor       = 0x80,       // set if any constructors were defined
-                                   // by the user
-    STRnoctor        = 0x100,      // no constructors allowed
-    STRgen           = 0x200,      // if struct is an instantiation of a
-                                   // template class, and was generated by
-                                   // that template
-    STRvtblext       = 0x400,      // generate vtbl[] only when first member function
-                                   // definition is encountered (see Fvtblgen)
-    STRexport        = 0x800,      // all member functions are to be _export
-    STRpredef        = 0x1000,     // a predefined struct
     STRunion         = 0x2000,     // actually, it's a union
     STRclass         = 0x4000,     // it's a class, not a struct
-    STRimport        = 0x8000,     // imported class
-    STRstaticmems    = 0x10000,    // class has static members
     STR0size         = 0x20000,    // zero sized struct
-    STRinstantiating = 0x40000,    // if currently being instantiated
-    STRexplicit      = 0x80000,    // if explicit template instantiation
-    STRgenctor0      = 0x100000,   // need to gen X::X()
     STRnotpod        = 0x200000,   // struct is not POD
 }
 
@@ -603,35 +524,11 @@ struct struct_t
     uint Salignsize;            // size of struct for alignment purposes
     ubyte Sstructalign;         // struct member alignment in effect
     struct_flags_t Sflags;
-    tym_t ptrtype;              // type of pointer to refer to classes by
     baseclass_t* Sbase;         // list of direct base classes
-    Symbol* Svptr;              // Symbol of vptr
-    Symbol* Stempsym;           // if this struct is an instantiation
-                                // of a template class, this is the
-                                // template class Symbol
 
     // For 64 bit Elf function ABI
     type* Sarg1type;
     type* Sarg2type;
-
-    /* For:
-     *  template<class T> struct A { };
-     *  template<class T> struct A<T *> { };
-     *
-     *  A<int> a;               // primary
-     * Gives:
-     *  Sarglist = <int>
-     *  Spr_arglist = NULL;
-     *
-     *  A<int*> a;              // specialization
-     * Gives:
-     *  Sarglist = <int>
-     *  Spr_arglist = <int*>;
-     */
-
-    param_t* Sarglist;          // if this struct is an instantiation
-                                // of a template class, this is the
-                                // actual arg list used
 }
 
 /**********************************

compiler/src/dmd/backend/cdef.d

@@ -83,9 +83,6 @@ else
 // Generate cleanup code
 enum TERMCODE = 0;
 
-// C++ Language Features
-enum ANGLE_BRACKET_HACK = 0;       // >> means two template arglist closes
-
 // C/C++ Language Features
 enum IMPLIED_PRAGMA_ONCE = 1;       // include guards count as #pragma once
 enum bool HEADER_LIST = true;
@@ -444,20 +441,7 @@ enum
     CFG3strcod      = 4,       // strings are placed in code segment
     CFG3eseqds      = 8,       // ES == DS at all times
     CFG3ptrchk      = 0x10,    // generate pointer validation code
-    CFG3strictproto = 0x20,    // strict prototyping
-    CFG3autoproto   = 0x40,    // auto prototyping
-    CFG3rtti        = 0x80,    // add RTTI support
-    CFG3relax       = 0x100,   // relaxed type checking (C only)
-    CFG3cpp         = 0x200,   // C++ compile
-    CFG3igninc      = 0x400,   // ignore standard include directory
-    CFG3mars        = 0x800,   // use mars libs and headers
-    CFG3nofar       = 0x1000,  // ignore __far and __huge keywords
-    CFG3noline      = 0x2000,  // do not output #line directives
-    CFG3comment     = 0x4000,  // leave comments in preprocessed output
-    CFG3cppcomment  = 0x8000,  // allow C++ style comments
     CFG3wkfloat     = 0x10000, // make floating point references weak externs
-    CFG3digraphs    = 0x20000, // support ANSI C++ digraphs
-    CFG3semirelax   = 0x40000, // moderate relaxed type checking (non-Windows targets)
     CFG3pic         = 0x80000, // position independent code
     CFG3pie         = 0x10_0000, // position independent executable (CFG3pic also set)
     CFG3ibt         = 0x20_0000, // indirect branch tracking
@@ -471,58 +455,14 @@ enum
     CFG4allcomdat        = 4,          // place all functions in COMDATs
     CFG4fastfloat        = 8,          // fast floating point (-ff)
     CFG4fdivcall         = 0x10,       // make function call for FDIV opcodes
-    CFG4tempinst         = 0x20,       // instantiate templates for undefined functions
     CFG4oldstdmangle     = 0x40,       // do stdcall mangling without @
-    CFG4pascal           = 0x80,       // default to pascal linkage
-    CFG4stdcall          = 0x100,      // default to std calling convention
-    CFG4cacheph          = 0x200,      // cache precompiled headers in memory
-    CFG4alternate        = 0x400,      // if alternate digraph tokens
     CFG4bool             = 0x800,      // support 'bool' as basic type
-    CFG4wchar_t          = 0x1000,     // support 'wchar_t' as basic type
-    CFG4notempexp        = 0x2000,     // no instantiation of template functions
-    CFG4anew             = 0x4000,     // allow operator new[] and delete[] overloading
-    CFG4oldtmangle       = 0x8000,     // use old template name mangling
-    CFG4dllrtl           = 0x10000,    // link with DLL RTL
-    CFG4noemptybaseopt   = 0x20000,    // turn off empty base class optimization
-    CFG4nowchar_t        = 0x40000,    // use unsigned short name mangling for wchar_t
-    CFG4forscope         = 0x80000,    // new C++ for scoping rules
-    CFG4warnccast        = 0x100000,   // warn about C style casts
-    CFG4adl              = 0x200000,   // argument dependent lookup
-    CFG4enumoverload     = 0x400000,   // enum overloading
-    CFG4implicitfromvoid = 0x800000,   // allow implicit cast from void* to T*
-    CFG4dependent        = 0x1000000,  // dependent / non-dependent lookup
-    CFG4wchar_is_long    = 0x2000000,  // wchar_t is 4 bytes
     CFG4underscore       = 0x4000000,  // prepend _ for C mangling
 }
 
 enum config_flags4_t CFG4optimized  = CFG4speed | CFG4space;
 enum config_flags4_t CFG4stackalign = CFG4speed;       // align stack to 8 bytes
 
-alias config_flags5_t = uint;
-enum
-{
-    CFG5debug       = 1,      // compile in __debug code
-    CFG5in          = 2,      // compile in __in code
-    CFG5out         = 4,      // compile in __out code
-    CFG5invariant   = 8,      // compile in __invariant code
-}
-
-/* CFGX: flags ignored in precompiled headers
- * CFGY: flags copied from precompiled headers into current config
- */
-enum config_flags_t CFGX   = CFGnowarning;
-enum config_flags2_t CFGX2 = CFG2warniserr | CFG2phuse | CFG2phgen | CFG2phauto |
-                             CFG2once | CFG2hdrdebug | CFG2noobj | CFG2noerrmax |
-                             CFG2expand | CFG2nodeflib | CFG2stomp | CFG2gms;
-enum config_flags3_t CFGX3 = CFG3strcod | CFG3ptrchk;
-enum config_flags4_t CFGX4 = CFG4optimized | CFG4fastfloat | CFG4fdivcall |
-                             CFG4tempinst | CFG4cacheph | CFG4notempexp |
-                             CFG4stackalign | CFG4dependent;
-
-enum config_flags4_t CFGY4 = CFG4nowchar_t | CFG4noemptybaseopt | CFG4adl |
-                             CFG4enumoverload | CFG4implicitfromvoid |
-                             CFG4wchar_is_long | CFG4underscore;
-
 // Configuration flags for HTOD executable
 alias htod_flags_t = uint;
 enum
@@ -567,7 +507,6 @@ struct Config
     config_flags2_t flags2;
     config_flags3_t flags3;
     config_flags4_t flags4;
-    config_flags5_t flags5;
 
     htod_flags_t htodFlags;     // configuration for htod
     ubyte ansi_c;               // strict ANSI C
@@ -707,7 +646,6 @@ enum SC : ubyte
     unde,           /// undefined
     auto_,          /// automatic (stack)
     static_,        /// statically allocated
-    thread,         /// thread local
     extern_,        /// external
     register,       /// registered variable
     pseudo,         /// pseudo register variable
@@ -718,35 +656,20 @@ enum SC : ubyte
     fastpar,        /// function parameter passed in register
     shadowreg,      /// function parameter passed in register, shadowed on stack
     typedef_,       /// type definition
-    explicit,       /// explicit
-    mutable,        /// mutable
-    label,          /// goto label
     struct_,        /// struct/class/union tag name
     enum_,          /// enum tag name
     field,          /// bit field of struct or union
     const_,         /// constant integer
     member,         /// member of struct or union
-    anon,           /// member of anonymous union
     inline,         /// for inline functions
     sinline,        /// for static inline functions
     einline,        /// for extern inline functions
-    overload,       /// for overloaded function names
-    friend,         /// friend of a class
-    virtual,        /// virtual function
     locstat,        /// static, but local to a function
-    template_,      /// class template
-    functempl,      /// function template
-    ftexpspec,      /// function template explicit specialization
-    linkage,        /// function linkage symbol
-    public_,        /// generate a pubdef for this
     comdef,         /// uninitialized common block
     bprel,          /// variable at fixed offset from frame pointer
-    namespace,      /// namespace
     alias_,         /// alias to another symbol
     funcalias,      /// alias to another function symbol
-    memalias,       /// alias to base class member
     stack,          /// offset from stack pointer (not frame pointer)
-    adl,            /// list of ADL symbols for overloading
 }
 
 enum SCMAX = SC.max + 1;

compiler/src/dmd/backend/cv8.d

@@ -238,7 +238,7 @@ void cv8_termfile(const(char)[] objfilename)
     buf.write16(2 + 1 + 1 + 2 + 1 + VERSION.length + 1);
     buf.write16(S_COMPILE);
     buf.writeByte(I64 ? 0xD0 : 6); // target machine AMD64 or x86 (Pentium II)
-    buf.writeByte(config.flags2 & CFG2gms ? (CPP != 0) : 'D'); // language index (C/C++/D)
+    buf.writeByte(config.flags2 & CFG2gms ? 0 : 'D'); // language index (C/C++/D)
     buf.write16(0x800 | (config.inline8087 ? 0 : (1<<3)));   // 32-bit, float package
     buf.writeByte(VERSION.length + 1);
     buf.writeByte('Z');