3rd attempt to make Bsucc an array

Author: WalterBright

compiler/src/dmd/backend/barray.d

@@ -190,8 +190,8 @@ struct Barray(T)
      */
     bool equals(ref const Barray rhs)
     {
-	if (array.length != rhs.length)
-	    return false;
+        if (array.length != rhs.length)
+            return false;
         foreach (i, ref t; array)
         {
             if (t != rhs.array[i])

compiler/src/dmd/backend/blockopt.d

@@ -307,6 +307,7 @@ void block_free(ref BlockOpt bo, block* b)
     if (b.Belem)
         el_free(b.Belem);
     list_free(&b.Bsucc,FPNULL);
+    b.Bsucca.dtor();
     b.Bpred.dtor();
     if (OPTIMIZER)
         block_optimizer_free(b);

compiler/src/dmd/backend/cc.d

@@ -205,6 +205,7 @@ nothrow:
     block* Bnext;               // pointer to next block in list
     list_t Bsucc;               // linked list of pointers to successors
                                 //     of this block
+    Barray!(block*) Bsucca;     // and the successor array copy of Bsucc
     Barray!(block*) Bpred;      // and the predecessor array
     int Bindex;                 // into created object stack
     int Bendindex;              // index at end of block
@@ -335,6 +336,44 @@ nothrow:
 @trusted
 inout(block)* list_block(inout list_t lst) { return cast(inout(block)*)list_ptr(lst); }
 
+// Convert Bsucc to Bsucca
+void convertBsuccToBsucca(block *b)
+{
+    for (; b; b = b.Bnext)
+    {
+        convertOneBsuccToBsucca(b);
+    }
+}
+
+void convertOneBsuccToBsucca(block *b)
+{
+    int n = list_nitems(b.Bsucc);
+    b.Bsucca.setLength(n);
+    int i;
+    foreach (bp; ListRange(b.Bsucc))
+    {
+        b.Bsucca[i] = list_block(bp);
+        ++i;
+    }
+    assert(i == b.Bsucca.length);
+}
+
+// Verify Bsucc has same contents as Bsucca
+void verifyBsuccMatchesBsucca(block *b)
+{
+    for (; b; b = b.Bnext)
+    {
+        int n = list_nitems(b.Bsucc);
+        assert(n == b.Bsucca.length);
+        int i;
+        foreach (bp; ListRange(b.Bsucc))
+        {
+            assert(b.Bsucca[i] == list_block(bp));
+            ++i;
+        }
+    }
+}
+
 /** Basic block control flow operators. **/
 
 enum BC : ubyte

compiler/src/dmd/backend/gflow.d

@@ -1339,6 +1339,7 @@ void flowlv(ref BlockOpt bo)
     foreach (b; bo.dfo[])
     {
         vec_copy(b.Binlv, b.Bgen);   // Binlv = Bgen
+convertOneBsuccToBsucca(b);
     }
 
     vec_t tmp = vec_calloc(globsym.length);
@@ -1353,9 +1354,10 @@ void flowlv(ref BlockOpt bo)
         {
             /* Bout = union of Bins of all successors to B. */
             bool first = true;
-            foreach (bl; ListRange(b.Bsucc))
+	    foreach (bl; b.Bsucca[])
+            //foreach (bl; ListRange(b.Bsucc))
             {
-                const inlv = list_block(bl).Binlv;
+                const inlv = bl.Binlv;
                 if (first)
                     vec_copy(b.Boutlv, inlv);
                 else
@@ -1656,6 +1658,7 @@ private void accumlv(vec_t GEN, vec_t KILL, const(elem)* n, const vec_t ambigsym
 @trusted
 void flowvbe(ref GlobalOptimizer go, ref BlockOpt bo)
 {
+if (1) assert(0);
     go.flowxx = VBE;
     aecpgenkill(go, bo);   // compute Bgen and Bkill for VBEs
     if (go.exptop <= 1)     /* if no candidates for VBEs            */

compiler/src/dmd/backend/gother.d

@@ -1066,9 +1066,10 @@ private int loopcheck(block* start,block* inc,block* rel)
 {
     if (!(start.Bflags & BFL.visited))
     {   start.Bflags |= BFL.visited;    /* guarantee eventual termination */
-        foreach (list; ListRange(start.Bsucc))
+
+        convertOneBsuccToBsucca(start);
+        foreach (b; start.Bsucca[])
         {
-            block* b = cast(block*) list_ptr(list);
             if (b != rel && (b == inc || loopcheck(b,inc,rel)))
                 return true;
         }

compiler/src/dmd/backend/x86/cgcod.d

@@ -88,7 +88,7 @@ void codgen(Symbol* sfunc)
 /***********************
  * Same as codgen(), but adding in CGstate argument
  * Params:
- *	cg = code generator state
+ *      cg = code generator state
  *      sfunc = function to generate code for
  */
 private @trusted
@@ -98,6 +98,10 @@ void codgenx(ref CGstate cg, Symbol* sfunc)
     assert(sfunc == funcsym_p);
     assert(cseg == funcsym_p.Sseg);
 
+    // Convert Bsucc to Bsucca
+    convertBsuccToBsucca(bo.startblock);
+    verifyBsuccMatchesBsucca(bo.startblock);
+
     cgreg_init();
     CSE.initialize();
 
@@ -2131,7 +2135,7 @@ bool cssave(elem* e, regm_t regm, bool opsflag)
     /*if (e.Ecount && e.Ecount == e.Ecomsub)*/
     if (e.Ecount && e.Ecomsub)
     {
-	CGstate* cg = &cgstate;
+        CGstate* cg = &cgstate;
         if (!opsflag && cg.pass != BackendPass.final_ && (I32 || I64))
             return false;
 
@@ -2579,7 +2583,7 @@ private void loadcse(ref CodeBuilder cdb,elem* e,reg_t reg,regm_t regm)
         //printf("CSE[%d] = %p, regm = %s\n", i, cse.e, regm_str(cse.regm));
         if (cse.regm & regm)
         {
-	    CGstate* cg = &cgstate;
+            CGstate* cg = &cgstate;
             cg.reflocal = true;
             cse.flags |= CSEload;    /* it was loaded        */
             cg.regcon.cse.value[reg] = e;

compiler/src/dmd/backend/x86/cgreg.d

@@ -607,15 +607,15 @@ void cgreg_spillreg_epilog(block* b,Symbol* s,ref CodeBuilder cdbstore, ref Code
     const bi = b.Bdfoidx;
     //printf("cgreg_spillreg_epilog(block %d, s = '%s')\n",bi,s.Sident.ptr);
     //assert(b.bc == BC.goto_);
-    if (!cgreg_gotoepilog(b.nthSucc(0), s))
+    if (!cgreg_gotoepilog(b.Bsucca[0], s))
         return;
 
     const live = vec_testbit(bi,s.Slvreg) != 0;
 
     // Look at successors to see if we need to load in/out of register
-    foreach (bl; ListRange(b.Bsucc))
+    foreach (bs; b.Bsucca[])
     {
-        const bpi = list_block(bl).Bdfoidx;
+        const bpi = bs.Bdfoidx;
         if (!vec_testbit(bpi,s.Srange))
             continue;
         if (vec_testbit(bpi,s.Slvreg))

compiler/src/dmd/backend/x86/cod3.d

@@ -1581,8 +1581,8 @@ static if (NTEXCEPTIONS)
             cg.refparam |= bl.bIasmrefparam;
             getregs(cdbx, iasm_regs(bl));         // mark destroyed registers
             code* c = cdbx.finish();
-            if (bl.Bsucc)
-            {   nextb = bl.nthSucc(0);
+            if (bl.Bsucca.length)
+            {   nextb = bl.Bsucca[0];
                 if (!bl.Bnext)
                 {
                     cdb.append(bl.Bcode);
@@ -2067,8 +2067,7 @@ void doswitch(ref CGstate cg, ref CodeBuilder cdb, block* b)
             reg = findreg(retregs);     // reg that result is in
             reg2 = NOREG;
         }
-        list_t bl = b.Bsucc;
-        block* bdefault = b.nthSucc(0);
+        block* bdefault = b.Bsucca[0];
         if (dword && mswsame)
         {
             cdb.genc2(0x81,modregrm(3,7,reg2),msw);   // CMP reg2,MSW
@@ -2088,8 +2087,7 @@ void doswitch(ref CGstate cg, ref CodeBuilder cdb, block* b)
         foreach (n, val; b.Bswitch)
         {
             casevals[n].val = val;
-            bl = list_next(bl);
-            casevals[n].target = list_block(bl);
+            casevals[n].target = b.Bsucca[1 + n];
 
             // See if we need a scratch register
             if (!cg.AArch64 && sreg == NOREG && I64 && sz == 8 && val != cast(int)val)
@@ -2564,11 +2562,9 @@ void outswitab(block* b)
         assert(*poffset == offset);
     }
 
-    list_t bl = b.Bsucc;
     foreach (n; 0 .. ncases)          // send out address table
     {
-        bl = list_next(bl);
-        objmod.reftocodeseg(seg,*poffset,list_block(bl).Boffset);
+        objmod.reftocodeseg(seg,*poffset,b.Bsucca[1 + n].Boffset);
         *poffset += tysize(TYnptr);
     }
     assert(*poffset == offset + ncases * tysize(TYnptr));

compiler/src/dmd/backend/x86/cod5.d

@@ -118,9 +118,9 @@ else
 
         // See if b is an epilog
         mark = 0;
-        foreach (bl; ListRange(b.Bsucc))
+        foreach (bl; b.Bsucca[])
         {
-            if (list_block(bl).Bflags & BFL.outsideprolog)
+            if (bl.Bflags & BFL.outsideprolog)
             {
                 if (mark == 2)
                     goto L1;
@@ -182,8 +182,8 @@ private void pe_add(block* b)
         return;
 
     b.Bflags |= BFL.outsideprolog;
-    foreach (bl; ListRange(b.Bsucc))
-        pe_add(list_block(bl));
+    foreach (bl; b.Bsucca[])
+        pe_add(bl);
 }
 
 /**********************************************

compiler/src/dmd/declaration.d

@@ -711,9 +711,9 @@ extern (C++) final class SymbolDeclaration : Declaration
 /***********************************************************
  * Generate Identifier for TypeInfo corresponding to `t`
  * Params:
- *	t = type to generate TypeInfo identifier for
+ *      t = type to generate TypeInfo identifier for
  * Returns:
- *	the identifier
+ *      the identifier
  */
 private Identifier getTypeInfoIdent(Type t)
 {