LogicSegment::pow2_ceil(): Fix potentіal integer overflow.

[pulseview.git] / pv / data / logicsegment.cpp

diff --git a/pv/data/logicsegment.cpp b/pv/data/logicsegment.cpp
index 38f4bf246c21a619e531be955af26075678c2569..5d6faf8f8fe1a5333f8130cfcb17725db99a07ab 100644 (file)
--- a/pv/data/logicsegment.cpp
+++ b/pv/data/logicsegment.cpp
@@ -17,12 +17,15 @@
  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "config.h" // For HAVE_UNALIGNED_LITTLE_ENDIAN_ACCESS
+
 #include <extdef.h>
 
 #include <cassert>
 #include <cmath>
 #include <cstdlib>
 #include <cstring>
+#include <cstdint>
 
 #include "logic.hpp"
 #include "logicsegment.hpp"
@@ -46,9 +49,9 @@ const int LogicSegment::MipMapScaleFactor = 1 << MipMapScalePower;
 const float LogicSegment::LogMipMapScaleFactor = logf(MipMapScaleFactor);
 const uint64_t LogicSegment::MipMapDataUnit = 64 * 1024; // bytes
 
-LogicSegment::LogicSegment(pv::data::Logic& owner, unsigned int unit_size,
-       uint64_t samplerate) :
-       Segment(samplerate, unit_size),
+LogicSegment::LogicSegment(pv::data::Logic& owner, uint32_t segment_id,
+       unsigned int unit_size, uint64_t samplerate) :
+       Segment(segment_id, samplerate, unit_size),
        owner_(owner),
        last_append_sample_(0)
 {
@@ -62,7 +65,7 @@ LogicSegment::~LogicSegment()
                free(l.data);
 }
 
-uint64_t LogicSegment::unpack_sample(const uint8_t *ptr) const
+inline uint64_t LogicSegment::unpack_sample(const uint8_t *ptr) const
 {
 #ifdef HAVE_UNALIGNED_LITTLE_ENDIAN_ACCESS
        return *(uint64_t*)ptr;
@@ -100,7 +103,7 @@ uint64_t LogicSegment::unpack_sample(const uint8_t *ptr) const
 #endif
 }
 
-void LogicSegment::pack_sample(uint8_t *ptr, uint64_t value)
+inline void LogicSegment::pack_sample(uint8_t *ptr, uint64_t value)
 {
 #ifdef HAVE_UNALIGNED_LITTLE_ENDIAN_ACCESS
        *(uint64_t*)ptr = value;
@@ -340,20 +343,19 @@ void LogicSegment::get_subsampled_edges(
                level = min_level;
 
                // We cannot fast-forward if there is no mip-map data at
-               // at the minimum level.
+               // the minimum level.
                fast_forward = (mip_map_[level].data != nullptr);
 
                if (min_length < MipMapScaleFactor) {
                        // Search individual samples up to the beginning of
                        // the next first level mip map block
-                       const uint64_t final_index = min(end,
-                               pow2_ceil(index, MipMapScalePower));
+                       const uint64_t final_index = min(end, pow2_ceil(index, MipMapScalePower));
 
                        for (; index < final_index &&
                                        (index & ~((uint64_t)(~0) << MipMapScalePower)) != 0;
                                        index++) {
-                               const bool sample =
-                                       (get_unpacked_sample(index) & sig_mask) != 0;
+
+                               const bool sample = (get_unpacked_sample(index) & sig_mask) != 0;
 
                                // If there was a change we cannot fast forward
                                if (sample != last_sample) {
@@ -365,15 +367,13 @@ void LogicSegment::get_subsampled_edges(
                        // If resolution is less than a mip map block,
                        // round up to the beginning of the mip-map block
                        // for this level of detail
-                       const int min_level_scale_power =
-                               (level + 1) * MipMapScalePower;
+                       const int min_level_scale_power = (level + 1) * MipMapScalePower;
                        index = pow2_ceil(index, min_level_scale_power);
                        if (index >= end)
                                break;
 
                        // We can fast forward only if there was no change
-                       const bool sample =
-                               (get_unpacked_sample(index) & sig_mask) != 0;
+                       const bool sample = (get_unpacked_sample(index) & sig_mask) != 0;
                        if (last_sample != sample)
                                fast_forward = false;
                }
@@ -388,32 +388,27 @@ void LogicSegment::get_subsampled_edges(
                        // Slide right and zoom out at the beginnings of mip-map
                        // blocks until we encounter a change
                        while (true) {
-                               const int level_scale_power =
-                                       (level + 1) * MipMapScalePower;
-                               const uint64_t offset =
-                                       index >> level_scale_power;
+                               const int level_scale_power = (level + 1) * MipMapScalePower;
+                               const uint64_t offset = index >> level_scale_power;
 
                                // Check if we reached the last block at this
                                // level, or if there was a change in this block
                                if (offset >= mip_map_[level].length ||
-                                       (get_subsample(level, offset) &
-                                               sig_mask))
+                                       (get_subsample(level, offset) & sig_mask))
                                        break;
 
                                if ((offset & ~((uint64_t)(~0) << MipMapScalePower)) == 0) {
                                        // If we are now at the beginning of a
                                        // higher level mip-map block ascend one
                                        // level
-                                       if (level + 1 >= ScaleStepCount ||
-                                               !mip_map_[level + 1].data)
+                                       if ((level + 1 >= ScaleStepCount) || (!mip_map_[level + 1].data))
                                                break;
 
                                        level++;
                                } else {
                                        // Slide right to the beginning of the
                                        // next mip map block
-                                       index = pow2_ceil(index + 1,
-                                               level_scale_power);
+                                       index = pow2_ceil(index + 1, level_scale_power);
                                }
                        }
 
@@ -422,16 +417,13 @@ void LogicSegment::get_subsampled_edges(
                        while (true) {
                                assert(mip_map_[level].data);
 
-                               const int level_scale_power =
-                                       (level + 1) * MipMapScalePower;
-                               const uint64_t offset =
-                                       index >> level_scale_power;
+                               const int level_scale_power = (level + 1) * MipMapScalePower;
+                               const uint64_t offset = index >> level_scale_power;
 
                                // Check if we reached the last block at this
                                // level, or if there was a change in this block
                                if (offset >= mip_map_[level].length ||
-                                               (get_subsample(level, offset) &
-                                               sig_mask)) {
+                                               (get_subsample(level, offset) & sig_mask)) {
                                        // Zoom in unless we reached the minimum
                                        // zoom
                                        if (level == min_level)
@@ -441,8 +433,7 @@ void LogicSegment::get_subsampled_edges(
                                } else {
                                        // Slide right to the beginning of the
                                        // next mip map block
-                                       index = pow2_ceil(index + 1,
-                                               level_scale_power);
+                                       index = pow2_ceil(index + 1, level_scale_power);
                                }
                        }
 
@@ -451,8 +442,7 @@ void LogicSegment::get_subsampled_edges(
                        // block
                        if (min_length < MipMapScaleFactor) {
                                for (; index < end; index++) {
-                                       const bool sample = (get_unpacked_sample(index) &
-                                               sig_mask) != 0;
+                                       const bool sample = (get_unpacked_sample(index) & sig_mask) != 0;
                                        if (sample != last_sample)
                                                break;
                                }
@@ -467,8 +457,7 @@ void LogicSegment::get_subsampled_edges(
                        break;
 
                // Store the final state
-               const bool final_sample =
-                       (get_unpacked_sample(final_index - 1) & sig_mask) != 0;
+               const bool final_sample = (get_unpacked_sample(final_index - 1) & sig_mask) != 0;
                edges.emplace_back(index, final_sample);
 
                index = final_index;
@@ -492,7 +481,7 @@ uint64_t LogicSegment::get_subsample(int level, uint64_t offset) const
 
 uint64_t LogicSegment::pow2_ceil(uint64_t x, unsigned int power)
 {
-       const uint64_t p = 1 << power;
+       const uint64_t p = UINT64_C(1) << power;
        return (x + p - 1) / p * p;
 }