change nthSucc to lengthx

Author: WalterBright

compiler/src/dmd/backend/cc.d

@@ -332,9 +332,30 @@ nothrow:
 @trusted
 block* Bsuccx(block* b, int n)        { return cast(block*)list_ptr(list_nth(b.Bsucc, n)); }
 
+@trusted
+int lengthx(LIST* bl) { return list_nitems((cast(block*)list_ptr(bl)).Bsucc); }
+
 @trusted
 inout(block)* list_block(inout list_t lst) { return cast(inout(block)*)list_ptr(lst); }
 
+struct BsuccArray
+{
+  nothrow @nogc @trusted:
+
+    this(list_t li)
+    {
+        this.li = li;
+    }
+
+    block* front() return { return list_block(li); }
+    void popFront() { li = li.next; }
+    bool empty() const { return !li; }
+
+  private:
+    list_t li;
+}
+
+
 /** Basic block control flow operators. **/
 
 enum BC : ubyte

compiler/src/dmd/backend/debugprint.d

@@ -299,10 +299,8 @@ void WRblockarray(block*[] bl)
 @trusted
 void WRblocklist(list_t bl)
 {
-    foreach (bl2; ListRange(bl))
+    foreach (b; BsuccArray(bl))
     {
-        block* b = list_block(bl2);
-
         if (b && b.Bweight)
             printf("B%d (%p) ",b.Bdfoidx,b);
         else

compiler/src/dmd/backend/eh.d

@@ -180,7 +180,7 @@ void except_fillInEHTable(Symbol* s)
             }
             i = b.Bscope_index + 1;
 
-            int nsucc = b.numSucc();
+            int nsucc = b.numSucc;
 
             if (config.ehmethod == EHmethod.EH_DM)
             {

compiler/src/dmd/backend/gflow.d

@@ -1353,9 +1353,9 @@ void flowlv(ref BlockOpt bo)
         {
             /* Bout = union of Bins of all successors to B. */
             bool first = true;
-            foreach (bl; ListRange(b.Bsucc))
+            foreach (bl; BsuccArray(b.Bsucc))
             {
-                const inlv = list_block(bl).Binlv;
+		const inlv = bl.Binlv;
                 if (first)
                     vec_copy(b.Boutlv, inlv);
                 else
@@ -1702,9 +1702,9 @@ void flowvbe(ref GlobalOptimizer go, ref BlockOpt bo)
 
             /* Bout = & of Bin of all successors */
             bool first = true;
-            foreach (bl; ListRange(b.Bsucc))
+            foreach (bl; BsuccArray(b.Bsucc))
             {
-                const vin = list_block(bl).Bin;
+                const vin = bl.Bin;
                 if (first)
                     vec_copy(b.Bout, vin);
                 else

compiler/src/dmd/backend/gloop.d

@@ -221,8 +221,8 @@ bool blockinit(ref BlockOpt bo)
           L1:
             foreach (blp; b.Bpred[])
             {
-                foreach (bls; ListRange(blp.Bsucc))
-                    if (list_block(bls) == b)
+                foreach (bls; BsuccArray(blp.Bsucc))
+                    if (bls == b)
                         continue L1;
                 assert(0);
             }
@@ -328,6 +328,7 @@ bool dom(ref BlockOpt bo, const block* A, const block* B)
  * Find all the loops.
  */
 
+@trusted
 private void findloops(ref BlockOpt bo, block*[] dfo, ref Loops loops)
 {
     freeloop(loops);
@@ -340,9 +341,8 @@ private void findloops(ref BlockOpt bo, block*[] dfo, ref Loops loops)
                                    // loops are found first)
     {
         assert(b);
-        foreach (bl; ListRange(b.Bsucc))
+        foreach (s; BsuccArray(b.Bsucc))
         {
-            block* s = list_block(bl);      // each successor s to b
             assert(s);
             if (dom(bo, s, b))              // if s dominates b
                 buildloop(bo, loops, s, b); // we found a loop
@@ -455,8 +455,8 @@ L1:
             vec_setbit(i,l.Lexit); /* ret blocks are exit blocks */
         else
         {
-            foreach (bl; ListRange(bo.dfo[i].Bsucc))
-                if (!vec_testbit(list_block(bl).Bdfoidx,l.Lloop))
+            foreach (b; BsuccArray(bo.dfo[i].Bsucc))
+                if (!vec_testbit(b.Bdfoidx,l.Lloop))
                 {
                     vec_setbit(i,l.Lexit);
                     break;
@@ -607,10 +607,10 @@ static if (1)
                 head.Bpred.subtracti(i);
 
                 // Any successors to predecessors to head blocks get redirected to head2
-                foreach (bl; ListRange(bs.Bsucc))
-                    if (list_block(bl) == head)
+                foreach (ref bl; BsuccArray(bs.Bsucc))
+                    if (bl == head)
                     {
-                        bl.ptr = cast(void*)head2;
+                        bl = head2;
                         goto L2;
                     }
                 assert(0);
@@ -634,10 +634,10 @@ else
                 (*pbl2).next = null;
                 auto bsucc = list_block(*pbl2).Bsucc;
                 pbl2 = &((*pbl2).next);
-                foreach (bl; ListRange(bsucc))
-                    if (list_block(bl) == head)
+                foreach (ref bl; BsuccArray(bsucc))
+                    if (bl == head)
                     {
-                        bl.ptr = cast(void*)head2;
+                        bl = head2;
                         goto L2;
                     }
                 assert(0);

compiler/src/dmd/backend/gother.d

@@ -1066,9 +1066,8 @@ 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))
+        foreach (b; BsuccArray(start.Bsucc))
         {
-            block* b = cast(block*) list_ptr(list);
             if (b != rel && (b == inc || loopcheck(b,inc,rel)))
                 return true;
         }

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

@@ -613,9 +613,9 @@ void cgreg_spillreg_epilog(block* b,Symbol* s,ref CodeBuilder cdbstore, ref Code
     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 (bl; BsuccArray(b.Bsucc))
     {
-        const bpi = list_block(bl).Bdfoidx;
+        const bpi = bl.Bdfoidx;
         if (!vec_testbit(bpi,s.Srange))
             continue;
         if (vec_testbit(bpi,s.Slvreg))

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; BsuccArray(b.Bsucc))
         {
-            if (list_block(bl).Bflags & BFL.outsideprolog)
+            if (bl.Bflags & BFL.outsideprolog)
             {
                 if (mark == 2)
                     goto L1;
@@ -175,15 +175,16 @@ void cod5_noprol(block* startblock)
  * the function prolog.
  */
 
+@trusted
 private void pe_add(block* b)
 {
     if (b.Bflags & BFL.outsideprolog ||
         need_prolog(b))
         return;
 
     b.Bflags |= BFL.outsideprolog;
-    foreach (bl; ListRange(b.Bsucc))
-        pe_add(list_block(bl));
+    foreach (bl; BsuccArray(b.Bsucc))
+        pe_add(bl);
 }
 
 /**********************************************