Revert "fixup! Optimize construction of little-endian segments"

This reverts commit d07d6de.

Author: bjorng

erts/emulator/beam/jit/beam_jit_bs.cpp

@@ -28,9 +28,6 @@
 #include "beam_jit_common.hpp"
 #include "beam_jit_bs.hpp"
 
-#include <iterator>
-#include <numeric>
-
 extern "C"
 {
 #include "beam_file.h"
@@ -89,41 +86,36 @@ std::vector<BscSegment> beam_jit_bsc_init(const Span<ArgVal> &args) {
     return segments;
 }
 
-template<typename It>
-static auto fold_group(std::vector<BscSegment> &segs, It first, It last) {
-    auto &back = segs.emplace_back(*first);
+static void push_group(std::vector<BscSegment> &segs,
+                       std::vector<BscSegment> &group) {
+    BscSegment seg;
 
-    back.action = BscSegment::action::ACCUMULATE_FIRST;
+    if (group.empty()) {
+        return;
+    }
 
-    return std::accumulate(std::next(first),
-                           last,
-                           back.effectiveSize,
-                           [&segs](Sint acc, const BscSegment &seg) {
-                               auto &back = segs.emplace_back(seg);
+    if ((group.back().flags & BSF_LITTLE) != 0) {
+        std::reverse(group.begin(), group.end());
+    }
 
-                               back.action = BscSegment::action::ACCUMULATE;
+    Sint groupSize = 0;
+    for (size_t i = 0; i < group.size(); i++) {
+        seg = group[i];
+        groupSize += seg.effectiveSize;
+        if (i == 0) {
+            seg.action = BscSegment::action::ACCUMULATE_FIRST;
+        } else {
+            seg.action = BscSegment::action::ACCUMULATE;
+        }
+        segs.push_back(seg);
+    }
 
-                               return acc + back.effectiveSize;
-                           });
-}
+    seg.type = am_integer;
+    seg.action = BscSegment::action::STORE;
+    seg.effectiveSize = groupSize;
+    segs.push_back(seg);
 
-static void push_group(std::vector<BscSegment> &segs,
-                       std::vector<BscSegment>::const_iterator start,
-                       std::vector<BscSegment>::const_iterator end) {
-    if (start < end) {
-        auto groupSize = ((start->flags & BSF_LITTLE) != 0)
-                                 ? fold_group(segs,
-                                              std::make_reverse_iterator(end),
-                                              std::make_reverse_iterator(start))
-                                 : fold_group(segs, start, end);
-
-        auto &seg = segs.emplace_back();
-
-        seg.type = am_integer;
-        seg.action = BscSegment::action::STORE;
-        seg.effectiveSize = groupSize;
-        seg.flags = start->flags;
-    }
+    group.clear();
 }
 
 /*
@@ -166,30 +158,25 @@ static void push_group(std::vector<BscSegment> &segs,
 std::vector<BscSegment> beam_jit_bsc_combine_segments(
         const std::vector<BscSegment> segments) {
     std::vector<BscSegment> segs;
-
-    auto group = segments.cend();
+    std::vector<BscSegment> group;
     Sint combinedSize = 0;
 
-    for (auto it = segments.cbegin(); it != segments.cend(); it++) {
-        auto &seg = *it;
-
+    for (auto seg : segments) {
         switch (seg.type) {
         case am_integer: {
             if (!(0 < seg.effectiveSize && seg.effectiveSize <= 64)) {
                 /* Unknown or too large size. Handle using the default
                  * DIRECT action. */
-                push_group(segs, group, it);
-                group = segments.cend();
-
+                push_group(segs, group);
                 segs.push_back(seg);
                 continue;
             }
 
             /* The current segment has a known size not exceeding 64
              * bits. Try to add it to the current group. */
-            if (group == segments.cend()) {
-                group = it;
 
+            if (group.empty()) {
+                group.push_back(seg);
                 combinedSize = seg.effectiveSize;
                 continue;
             }
@@ -198,8 +185,9 @@ std::vector<BscSegment> beam_jit_bsc_combine_segments(
              * Append the current segment to the group only if it is
              * compatible and will fit. */
 
+            auto &prev = group.back();
             bool sameEndian =
-                    (seg.flags & BSF_LITTLE) == (group->flags & BSF_LITTLE);
+                    (seg.flags & BSF_LITTLE) == (prev.flags & BSF_LITTLE);
 
             /* Big-endian segments can always be grouped (if the size
              * does not exceed 64 bits). Little-endian segments can
@@ -211,31 +199,30 @@ std::vector<BscSegment> beam_jit_bsc_combine_segments(
             if (sameEndian && combinedSize + seg.effectiveSize <= 64 &&
                 suitableSizes) {
                 combinedSize += seg.effectiveSize;
+                group.push_back(seg);
                 continue;
             }
 
             /*
              * Not possible to fit anything more into the group.
              * Flush the group and start a new group.
              */
-            push_group(segs, group, it);
-            group = it;
+            push_group(segs, group);
 
+            group.push_back(seg);
             combinedSize = seg.effectiveSize;
             break;
         }
         default:
-            push_group(segs, group, it);
-            group = segments.cend();
-
+            push_group(segs, group);
             segs.push_back(seg);
             break;
         }
     }
 
-    push_group(segs, group, segments.cend());
+    push_group(segs, group);
 
-    /* Calculate bit offsets for ACCUMULATE and STORE segments. */
+    /* Calculate bit offsets for each ACCUMULATE segment. */
 
     Uint offset = 0;
     for (int i = segs.size() - 1; i >= 0; i--) {