_ZN4epee7strspanIhNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS_4spanIKT_EERKT0_: 180| 4.45k| { 181| 4.45k| static_assert(std::is_same(), "unexpected source type"); 182| 4.45k| static_assert(std::is_same() || std::is_same() || std::is_same() || std::is_same(), "Unexpected destination type"); 183| 4.45k| return {reinterpret_cast(s.data()), s.size()}; 184| 4.45k| } _ZN4epee4spanIKhEC2IS1_vEEPT_m: 82| 4.45k| : ptr(src_ptr), len(count) {} _ZNK4epee4spanIKhE4sizeEv: 109| 8.77k| constexpr std::size_t size() const noexcept { return len; } _ZNK4epee4spanIKhE4dataEv: 108| 8.75k| constexpr pointer data() const noexcept { return ptr; } _ZN4epee13serialization16portable_storageC2Ev: 59| 4.45k| portable_storage(){} _ZN4epee13serialization16portable_storage16load_from_binaryERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPKNS1_8limits_tE: 92| 4.45k| { 93| 4.45k| return load_from_binary(epee::strspan(target), limits); 94| 4.45k| } _ZN4epee13serialization16portable_storageD2Ev: 60| 4.45k| virtual ~portable_storage(){} _ZN4epee13serialization15entry_containerIbE7reserveERNSt3__15dequeIbNS3_9allocatorIbEEEEm: 76| 5.62k| template<> struct entry_container { typedef std::deque type; static void reserve(type &t, size_t n) {} }; _ZN4epee13serialization13array_entry_tINS0_7sectionEEC2ERKS3_: 85| 194k| array_entry_t(const array_entry_t& other):m_array(other.m_array), m_it(m_array.end()){} _ZN4epee13serialization13array_entry_tImEC2ERKS2_: 85| 8.23k| array_entry_t(const array_entry_t& other):m_array(other.m_array), m_it(m_array.end()){} _ZN4epee13serialization13array_entry_tIjEC2ERKS2_: 85| 7.36k| array_entry_t(const array_entry_t& other):m_array(other.m_array), m_it(m_array.end()){} _ZN4epee13serialization13array_entry_tItEC2ERKS2_: 85| 73.5k| array_entry_t(const array_entry_t& other):m_array(other.m_array), m_it(m_array.end()){} _ZN4epee13serialization13array_entry_tIhEC2ERKS2_: 85| 13.7k| array_entry_t(const array_entry_t& other):m_array(other.m_array), m_it(m_array.end()){} _ZN4epee13serialization13array_entry_tIlEC2ERKS2_: 85| 8.52k| array_entry_t(const array_entry_t& other):m_array(other.m_array), m_it(m_array.end()){} _ZN4epee13serialization13array_entry_tIiEC2ERKS2_: 85| 17.1k| array_entry_t(const array_entry_t& other):m_array(other.m_array), m_it(m_array.end()){} _ZN4epee13serialization13array_entry_tIsEC2ERKS2_: 85| 24.3k| array_entry_t(const array_entry_t& other):m_array(other.m_array), m_it(m_array.end()){} _ZN4epee13serialization13array_entry_tIaEC2ERKS2_: 85| 9.44k| array_entry_t(const array_entry_t& other):m_array(other.m_array), m_it(m_array.end()){} _ZN4epee13serialization13array_entry_tIdEC2ERKS2_: 85| 21.6k| array_entry_t(const array_entry_t& other):m_array(other.m_array), m_it(m_array.end()){} _ZN4epee13serialization13array_entry_tIbEC2ERKS2_: 85| 90.6k| array_entry_t(const array_entry_t& other):m_array(other.m_array), m_it(m_array.end()){} _ZN4epee13serialization13array_entry_tINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEC2ERKS9_: 85| 52.3k| array_entry_t(const array_entry_t& other):m_array(other.m_array), m_it(m_array.end()){} _ZN4epee13serialization13array_entry_tIN5boost7variantINS2_6detail7variant14recursive_flagINS1_INS0_7sectionEEEEEJNS1_ImEENS1_IjEENS1_ItEENS1_IhEENS1_IlEENS1_IiEENS1_IsEENS1_IaEENS1_IdEENS1_IbEENS1_INSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEES8_NS1_INS2_18recursive_variant_EEEEEEEC2ERKSV_: 85| 9.68k| array_entry_t(const array_entry_t& other):m_array(other.m_array), m_it(m_array.end()){} _ZN4epee13serialization13array_entry_tIlEC2Ev: 84| 989| array_entry_t():m_it(m_array.end()){} _ZN4epee13serialization13array_entry_tIlE7reserveEm: 135| 883| { 136| 883| entry_container::reserve(m_array, n); 137| 883| } _ZN4epee13serialization15entry_containerIlE7reserveERNSt3__16vectorIlNS3_9allocatorIlEEEEm: 75| 883| template struct entry_container { typedef std::vector type; static void reserve(type &t, size_t n) { t.reserve(n); } }; _ZN4epee13serialization13array_entry_tIiEC2Ev: 84| 1.50k| array_entry_t():m_it(m_array.end()){} _ZN4epee13serialization13array_entry_tIiE7reserveEm: 135| 1.39k| { 136| 1.39k| entry_container::reserve(m_array, n); 137| 1.39k| } _ZN4epee13serialization15entry_containerIiE7reserveERNSt3__16vectorIiNS3_9allocatorIiEEEEm: 75| 1.39k| template struct entry_container { typedef std::vector type; static void reserve(type &t, size_t n) { t.reserve(n); } }; _ZN4epee13serialization13array_entry_tIsEC2Ev: 84| 4.30k| array_entry_t():m_it(m_array.end()){} _ZN4epee13serialization13array_entry_tIsE7reserveEm: 135| 4.20k| { 136| 4.20k| entry_container::reserve(m_array, n); 137| 4.20k| } _ZN4epee13serialization15entry_containerIsE7reserveERNSt3__16vectorIsNS3_9allocatorIsEEEEm: 75| 4.20k| template struct entry_container { typedef std::vector type; static void reserve(type &t, size_t n) { t.reserve(n); } }; _ZN4epee13serialization13array_entry_tIaEC2Ev: 84| 1.28k| array_entry_t():m_it(m_array.end()){} _ZN4epee13serialization13array_entry_tIaE7reserveEm: 135| 1.17k| { 136| 1.17k| entry_container::reserve(m_array, n); 137| 1.17k| } _ZN4epee13serialization15entry_containerIaE7reserveERNSt3__16vectorIaNS3_9allocatorIaEEEEm: 75| 1.17k| template struct entry_container { typedef std::vector type; static void reserve(type &t, size_t n) { t.reserve(n); } }; _ZN4epee13serialization13array_entry_tImEC2Ev: 84| 905| array_entry_t():m_it(m_array.end()){} _ZN4epee13serialization13array_entry_tImE7reserveEm: 135| 796| { 136| 796| entry_container::reserve(m_array, n); 137| 796| } _ZN4epee13serialization15entry_containerImE7reserveERNSt3__16vectorImNS3_9allocatorImEEEEm: 75| 796| template struct entry_container { typedef std::vector type; static void reserve(type &t, size_t n) { t.reserve(n); } }; _ZN4epee13serialization13array_entry_tIjEC2Ev: 84| 925| array_entry_t():m_it(m_array.end()){} _ZN4epee13serialization13array_entry_tIjE7reserveEm: 135| 818| { 136| 818| entry_container::reserve(m_array, n); 137| 818| } _ZN4epee13serialization15entry_containerIjE7reserveERNSt3__16vectorIjNS3_9allocatorIjEEEEm: 75| 818| template struct entry_container { typedef std::vector type; static void reserve(type &t, size_t n) { t.reserve(n); } }; _ZN4epee13serialization13array_entry_tItEC2Ev: 84| 4.51k| array_entry_t():m_it(m_array.end()){} _ZN4epee13serialization13array_entry_tItE7reserveEm: 135| 4.41k| { 136| 4.41k| entry_container::reserve(m_array, n); 137| 4.41k| } _ZN4epee13serialization15entry_containerItE7reserveERNSt3__16vectorItNS3_9allocatorItEEEEm: 75| 4.41k| template struct entry_container { typedef std::vector type; static void reserve(type &t, size_t n) { t.reserve(n); } }; _ZN4epee13serialization13array_entry_tIhEC2Ev: 84| 1.28k| array_entry_t():m_it(m_array.end()){} _ZN4epee13serialization13array_entry_tIhE7reserveEm: 135| 1.20k| { 136| 1.20k| entry_container::reserve(m_array, n); 137| 1.20k| } _ZN4epee13serialization15entry_containerIhE7reserveERNSt3__16vectorIhNS3_9allocatorIhEEEEm: 75| 1.20k| template struct entry_container { typedef std::vector type; static void reserve(type &t, size_t n) { t.reserve(n); } }; _ZN4epee13serialization13array_entry_tIdEC2Ev: 84| 1.50k| array_entry_t():m_it(m_array.end()){} _ZN4epee13serialization13array_entry_tIdE7reserveEm: 135| 1.39k| { 136| 1.39k| entry_container::reserve(m_array, n); 137| 1.39k| } _ZN4epee13serialization15entry_containerIdE7reserveERNSt3__16vectorIdNS3_9allocatorIdEEEEm: 75| 1.39k| template struct entry_container { typedef std::vector type; static void reserve(type &t, size_t n) { t.reserve(n); } }; _ZN4epee13serialization13array_entry_tIbEC2Ev: 84| 5.73k| array_entry_t():m_it(m_array.end()){} _ZN4epee13serialization13array_entry_tIbE7reserveEm: 135| 5.62k| { 136| 5.62k| entry_container::reserve(m_array, n); 137| 5.62k| } _ZN4epee13serialization13array_entry_tINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEC2Ev: 84| 14.6k| array_entry_t():m_it(m_array.end()){} _ZN4epee13serialization13array_entry_tINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE7reserveEm: 135| 14.5k| { 136| 14.5k| entry_container::reserve(m_array, n); 137| 14.5k| } _ZN4epee13serialization15entry_containerINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE7reserveERNS2_6vectorIS8_NS6_IS8_EEEEm: 75| 14.5k| template struct entry_container { typedef std::vector type; static void reserve(type &t, size_t n) { t.reserve(n); } }; _ZN4epee13serialization13array_entry_tINS0_7sectionEE7reserveEm: 135| 13.5k| { 136| 13.5k| entry_container::reserve(m_array, n); 137| 13.5k| } _ZN4epee13serialization15entry_containerINS0_7sectionEE7reserveERNSt3__16vectorIS2_NS4_9allocatorIS2_EEEEm: 75| 13.5k| template struct entry_container { typedef std::vector type; static void reserve(type &t, size_t n) { t.reserve(n); } }; _ZN4epee13serialization13array_entry_tIN5boost7variantINS2_6detail7variant14recursive_flagINS1_INS0_7sectionEEEEEJNS1_ImEENS1_IjEENS1_ItEENS1_IhEENS1_IlEENS1_IiEENS1_IsEENS1_IaEENS1_IdEENS1_IbEENS1_INSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEES8_NS1_INS2_18recursive_variant_EEEEEEEC2Ev: 84| 1.74k| array_entry_t():m_it(m_array.end()){} _ZN4epee13serialization13array_entry_tIN5boost7variantINS2_6detail7variant14recursive_flagINS1_INS0_7sectionEEEEEJNS1_ImEENS1_IjEENS1_ItEENS1_IhEENS1_IlEENS1_IiEENS1_IsEENS1_IaEENS1_IdEENS1_IbEENS1_INSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEES8_NS1_INS2_18recursive_variant_EEEEEEE7reserveEm: 135| 1.64k| { 136| 1.64k| entry_container::reserve(m_array, n); 137| 1.64k| } _ZN4epee13serialization15entry_containerIN5boost7variantINS2_6detail7variant14recursive_flagINS0_13array_entry_tINS0_7sectionEEEEEJNS7_ImEENS7_IjEENS7_ItEENS7_IhEENS7_IlEENS7_IiEENS7_IsEENS7_IaEENS7_IdEENS7_IbEENS7_INSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEES9_NS7_INS2_18recursive_variant_EEEEEEE7reserveERNSL_6vectorISV_NSP_ISV_EEEEm: 75| 1.64k| template struct entry_container { typedef std::vector type; static void reserve(type &t, size_t n) { t.reserve(n); } }; _ZN4epee13serialization13array_entry_tINS0_7sectionEEC2Ev: 84| 13.6k| array_entry_t():m_it(m_array.end()){} _ZN4epee13serialization23throwable_buffer_reader4readIbEEvRT_: 165| 14.7M| { 166| 14.7M| RECURSION_LIMITATION(); ------------------ | | 104| 14.7M|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 167| 14.7M| static_assert(std::is_pod::value, "POD type expected"); 168| 14.7M| static_assert(sizeof(bool) == sizeof(uint8_t), "We really shouldn't use bool directly in serialization code. Replace it with uint8_t if this assert triggers!"); 169| 14.7M| uint8_t t; 170| 14.7M| read(&t, sizeof(t)); 171| 14.7M| CHECK_AND_ASSERT_THROW_MES(t <= 1, "Invalid bool value " << t); ------------------ | | 175| 14.7M|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 67|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 67|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 67|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 67|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 67|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 67|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 67| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 67] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 67| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 67, False: 14.7M] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 172| 14.7M| pod_val = (t != 0); 173| 14.7M| } _ZN4epee13serialization23throwable_buffer_reader27recursuion_limitation_guardC2ERm: 93| 87.6M| recursuion_limitation_guard(size_t& counter):m_counter_ref(counter) 94| 87.6M| { 95| 87.6M| ++m_counter_ref; 96| 87.6M| CHECK_AND_ASSERT_THROW_MES(m_counter_ref < EPEE_PORTABLE_STORAGE_RECURSION_LIMIT_INTERNAL, "Wrong blob data in portable storage: recursion limitation (" << EPEE_PORTABLE_STORAGE_RECURSION_LIMIT_INTERNAL << ") exceeded"); ------------------ | | 175| 87.6M|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 8|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 8|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 8|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 8|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 8|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 8|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 8| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 8] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 8| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 8, False: 87.6M] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 97| 87.6M| } _ZN4epee13serialization23throwable_buffer_reader4readEPvm: 136| 24.2M| { 137| 24.2M| RECURSION_LIMITATION(); ------------------ | | 104| 24.2M|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 138| 24.2M| CHECK_AND_ASSERT_THROW_MES(m_count >= count, " attempt to read " << count << " bytes from buffer with " << m_count << " bytes remained"); ------------------ | | 175| 24.2M|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 1.96k|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 1.96k|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 1.96k|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 1.96k|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 1.96k|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 1.96k|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 1.96k| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 1.96k] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 1.96k| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 1.96k, False: 24.2M] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 139| 24.2M| memcpy(target, m_ptr, count); 140| 24.2M| m_ptr += count; 141| 24.2M| m_count -= count; 142| 24.2M| } _ZN4epee13serialization23throwable_buffer_reader27recursuion_limitation_guardD2Ev: 99| 87.6M| { 100| 87.6M| CHECK_AND_ASSERT_THROW_MES(m_counter_ref != 0, "Internal error: m_counter_ref == 0 while ~recursuion_limitation_guard()"); ------------------ | | 175| 87.6M|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 0, False: 87.6M] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 101| 87.6M| --m_counter_ref; 102| 87.6M| } _ZN4epee13serialization23throwable_buffer_readerC2EPKvm: 119| 4.31k| { 120| 4.31k| if(!ptr) ------------------ | Branch (120:10): [True: 0, False: 4.31k] ------------------ 121| 0| throw std::runtime_error("throwable_buffer_reader: ptr==nullptr"); 122| 4.31k| if(!sz) ------------------ | Branch (122:10): [True: 1, False: 4.31k] ------------------ 123| 1| throw std::runtime_error("throwable_buffer_reader: sz==0"); 124| 4.31k| m_ptr = (uint8_t*)ptr; 125| 4.31k| m_count = sz; 126| 4.31k| m_recursion_count = 0; 127| 4.31k| m_objects = 0; 128| 4.31k| m_fields = 0; 129| 4.31k| m_strings = 0; 130| 4.31k| max_objects = std::numeric_limits::max(); 131| 4.31k| max_fields = std::numeric_limits::max(); 132| 4.31k| max_strings = std::numeric_limits::max(); 133| 4.31k| } _ZN4epee13serialization23throwable_buffer_reader4readERNS0_7sectionE: 330| 1.06M| { 331| 1.06M| RECURSION_LIMITATION(); ------------------ | | 104| 1.06M|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 332| 1.06M| sec.m_entries.clear(); 333| 1.06M| size_t count = read_varint(); 334| 1.06M| CHECK_AND_ASSERT_THROW_MES(count <= max_fields - m_fields, "Too many object fields"); ------------------ | | 175| 1.06M|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 1|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 1|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 1|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 1|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 1|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 1|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 1| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 1] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 1| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 1, False: 1.06M] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 335| 1.06M| m_fields += count; 336| 1.14M| while(count--) ------------------ | Branch (336:13): [True: 72.1k, False: 1.06M] ------------------ 337| 72.1k| { 338| | //read section name string 339| 72.1k| std::string sec_name; 340| 72.1k| read_sec_name(sec_name); 341| 72.1k| const auto insert_loc = sec.m_entries.lower_bound(sec_name); 342| 72.1k| CHECK_AND_ASSERT_THROW_MES(insert_loc == sec.m_entries.end() || insert_loc->first != sec_name, "duplicate key: " << sec_name); ------------------ | | 175| 100k|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 42|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 42|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 42|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 42|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 42|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 42|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 42| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 42] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 42| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 42, False: 72.0k] | | | Branch (175:60): [True: 44.1k, False: 27.9k] | | | Branch (175:60): [True: 27.9k, False: 42] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 343| 72.0k| sec.m_entries.emplace_hint(insert_loc, std::move(sec_name), load_storage_entry()); 344| 72.0k| } 345| 1.06M| } _ZN4epee13serialization23throwable_buffer_reader11read_varintEv: 239| 4.98M| { 240| 4.98M| RECURSION_LIMITATION(); ------------------ | | 104| 4.98M|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 241| 4.98M| CHECK_AND_ASSERT_THROW_MES(m_count >= 1, "empty buff, expected place for varint"); ------------------ | | 175| 4.98M|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 159|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 159|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 159|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 159|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 159|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 159|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 159| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 159] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 159| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 159, False: 4.98M] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 242| 4.98M| size_t v = 0; 243| 4.98M| uint8_t size_mask = (*(uint8_t*)m_ptr) &PORTABLE_RAW_SIZE_MARK_MASK; ------------------ | | 41| 4.98M|#define PORTABLE_RAW_SIZE_MARK_MASK 0x03 ------------------ 244| 4.98M| switch (size_mask) 245| 4.98M| { 246| 4.96M| case PORTABLE_RAW_SIZE_MARK_BYTE: v = read();break; ------------------ | | 42| 4.96M|#define PORTABLE_RAW_SIZE_MARK_BYTE 0 ------------------ | Branch (246:7): [True: 4.96M, False: 22.0k] ------------------ 247| 16.5k| case PORTABLE_RAW_SIZE_MARK_WORD: v = read();break; ------------------ | | 43| 16.5k|#define PORTABLE_RAW_SIZE_MARK_WORD 1 ------------------ | Branch (247:7): [True: 16.5k, False: 4.97M] ------------------ 248| 2.24k| case PORTABLE_RAW_SIZE_MARK_DWORD: v = read();break; ------------------ | | 44| 2.24k|#define PORTABLE_RAW_SIZE_MARK_DWORD 2 ------------------ | Branch (248:7): [True: 2.24k, False: 4.98M] ------------------ 249| 3.22k| case PORTABLE_RAW_SIZE_MARK_INT64: v = read();break; ------------------ | | 45| 3.22k|#define PORTABLE_RAW_SIZE_MARK_INT64 3 ------------------ | Branch (249:7): [True: 3.22k, False: 4.98M] ------------------ 250| 0| default: ------------------ | Branch (250:7): [True: 0, False: 4.98M] ------------------ 251| 0| CHECK_AND_ASSERT_THROW_MES(false, "unknown varint size_mask = " << size_mask); ------------------ | | 175| 0|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [Folded - Ignored] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 252| 4.98M| } 253| 4.98M| v >>= 2; 254| 4.98M| return v; 255| 4.98M| } _ZN4epee13serialization23throwable_buffer_reader4readIhEET_v: 177| 6.01M| { 178| 6.01M| RECURSION_LIMITATION(); ------------------ | | 104| 6.01M|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 179| 6.01M| t_type v; 180| 6.01M| read(v); 181| 6.01M| return v; 182| 6.01M| } _ZN4epee13serialization23throwable_buffer_reader4readIhEEvRT_: 156| 6.16M| { 157| 6.16M| RECURSION_LIMITATION(); ------------------ | | 104| 6.16M|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 158| 6.16M| static_assert(std::is_pod::value, "POD type expected"); 159| 6.16M| read(&pod_val, sizeof(pod_val)); 160| 6.16M| pod_val = CONVERT_POD(pod_val); ------------------ | | 45| 6.16M|#define CONVERT_POD(x) (x) ------------------ 161| 6.16M| } _ZN4epee13serialization23throwable_buffer_reader4readItEET_v: 177| 672k| { 178| 672k| RECURSION_LIMITATION(); ------------------ | | 104| 672k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 179| 672k| t_type v; 180| 672k| read(v); 181| 672k| return v; 182| 672k| } _ZN4epee13serialization23throwable_buffer_reader4readItEEvRT_: 156| 673k| { 157| 673k| RECURSION_LIMITATION(); ------------------ | | 104| 673k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 158| 673k| static_assert(std::is_pod::value, "POD type expected"); 159| 673k| read(&pod_val, sizeof(pod_val)); 160| 673k| pod_val = CONVERT_POD(pod_val); ------------------ | | 45| 673k|#define CONVERT_POD(x) (x) ------------------ 161| 673k| } _ZN4epee13serialization23throwable_buffer_reader4readIjEET_v: 177| 267k| { 178| 267k| RECURSION_LIMITATION(); ------------------ | | 104| 267k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 179| 267k| t_type v; 180| 267k| read(v); 181| 267k| return v; 182| 267k| } _ZN4epee13serialization23throwable_buffer_reader4readIjEEvRT_: 156| 267k| { 157| 267k| RECURSION_LIMITATION(); ------------------ | | 104| 267k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 158| 267k| static_assert(std::is_pod::value, "POD type expected"); 159| 267k| read(&pod_val, sizeof(pod_val)); 160| 267k| pod_val = CONVERT_POD(pod_val); ------------------ | | 45| 267k|#define CONVERT_POD(x) (x) ------------------ 161| 267k| } _ZN4epee13serialization23throwable_buffer_reader4readImEET_v: 177| 180k| { 178| 180k| RECURSION_LIMITATION(); ------------------ | | 104| 180k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 179| 180k| t_type v; 180| 180k| read(v); 181| 180k| return v; 182| 180k| } _ZN4epee13serialization23throwable_buffer_reader4readImEEvRT_: 156| 181k| { 157| 181k| RECURSION_LIMITATION(); ------------------ | | 104| 181k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 158| 181k| static_assert(std::is_pod::value, "POD type expected"); 159| 181k| read(&pod_val, sizeof(pod_val)); 160| 181k| pod_val = CONVERT_POD(pod_val); ------------------ | | 45| 181k|#define CONVERT_POD(x) (x) ------------------ 161| 181k| } _ZN4epee13serialization23throwable_buffer_reader13read_sec_nameERNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 145| 72.1k| { 146| 72.1k| RECURSION_LIMITATION(); ------------------ | | 104| 72.1k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 147| 72.1k| uint8_t name_len = 0; 148| 72.1k| read(name_len); 149| 72.1k| CHECK_AND_ASSERT_THROW_MES(name_len > 0, "Section name is missing"); ------------------ | | 175| 72.1k|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 105|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 105|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 105|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 105|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 105|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 105|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 105| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 105] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 105| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 105, False: 71.9k] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 150| 71.9k| sce_name.resize(name_len); 151| 71.9k| read((void*)sce_name.data(), name_len); 152| 71.9k| } _ZN4epee13serialization23throwable_buffer_reader18load_storage_entryEv: 301| 70.4k| { 302| 70.4k| RECURSION_LIMITATION(); ------------------ | | 104| 70.4k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 303| 70.4k| uint8_t ent_type = 0; 304| 70.4k| read(ent_type); 305| 70.4k| if(ent_type&SERIALIZE_FLAG_ARRAY) ------------------ | | 66| 70.4k|#define SERIALIZE_FLAG_ARRAY 0x80 ------------------ | Branch (305:10): [True: 52.0k, False: 18.3k] ------------------ 306| 52.0k| return load_storage_array_entry(ent_type); 307| | 308| 18.3k| switch(ent_type) 309| 18.3k| { 310| 2.26k| case SERIALIZE_TYPE_INT64: return read_se(); ------------------ | | 52| 2.26k|#define SERIALIZE_TYPE_INT64 1 ------------------ | Branch (310:7): [True: 2.26k, False: 16.0k] ------------------ 311| 683| case SERIALIZE_TYPE_INT32: return read_se(); ------------------ | | 53| 683|#define SERIALIZE_TYPE_INT32 2 ------------------ | Branch (311:7): [True: 683, False: 17.6k] ------------------ 312| 488| case SERIALIZE_TYPE_INT16: return read_se(); ------------------ | | 54| 488|#define SERIALIZE_TYPE_INT16 3 ------------------ | Branch (312:7): [True: 488, False: 17.8k] ------------------ 313| 4.11k| case SERIALIZE_TYPE_INT8: return read_se(); ------------------ | | 55| 4.11k|#define SERIALIZE_TYPE_INT8 4 ------------------ | Branch (313:7): [True: 4.11k, False: 14.2k] ------------------ 314| 567| case SERIALIZE_TYPE_UINT64: return read_se(); ------------------ | | 56| 567|#define SERIALIZE_TYPE_UINT64 5 ------------------ | Branch (314:7): [True: 567, False: 17.7k] ------------------ 315| 509| case SERIALIZE_TYPE_UINT32: return read_se(); ------------------ | | 57| 509|#define SERIALIZE_TYPE_UINT32 6 ------------------ | Branch (315:7): [True: 509, False: 17.8k] ------------------ 316| 368| case SERIALIZE_TYPE_UINT16: return read_se(); ------------------ | | 58| 368|#define SERIALIZE_TYPE_UINT16 7 ------------------ | Branch (316:7): [True: 368, False: 17.9k] ------------------ 317| 1.69k| case SERIALIZE_TYPE_UINT8: return read_se(); ------------------ | | 59| 1.69k|#define SERIALIZE_TYPE_UINT8 8 ------------------ | Branch (317:7): [True: 1.69k, False: 16.6k] ------------------ 318| 453| case SERIALIZE_TYPE_DOUBLE: return read_se(); ------------------ | | 60| 453|#define SERIALIZE_TYPE_DOUBLE 9 ------------------ | Branch (318:7): [True: 453, False: 17.8k] ------------------ 319| 579| case SERIALIZE_TYPE_BOOL: return read_se(); ------------------ | | 62| 579|#define SERIALIZE_TYPE_BOOL 11 ------------------ | Branch (319:7): [True: 579, False: 17.7k] ------------------ 320| 739| case SERIALIZE_TYPE_STRING: return read_se(); ------------------ | | 61| 739|#define SERIALIZE_TYPE_STRING 10 ------------------ | Branch (320:7): [True: 739, False: 17.5k] ------------------ 321| 4.59k| case SERIALIZE_TYPE_OBJECT: return read_se
(); ------------------ | | 63| 4.59k|#define SERIALIZE_TYPE_OBJECT 12 ------------------ | Branch (321:7): [True: 4.59k, False: 13.7k] ------------------ 322| 940| case SERIALIZE_TYPE_ARRAY: return read_se(); ------------------ | | 64| 940|#define SERIALIZE_TYPE_ARRAY 13 ------------------ | Branch (322:7): [True: 940, False: 17.3k] ------------------ 323| 63| default: ------------------ | Branch (323:7): [True: 63, False: 18.2k] ------------------ 324| 63| CHECK_AND_ASSERT_THROW_MES(false, "unknown entry_type code = " << ent_type); ------------------ | | 175| 63|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 63|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 63|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 63|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 63|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 63|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 63|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 63| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 63] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 63| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [Folded - Ignored] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 325| 18.3k| } 326| 0| return read_se(); // unreachable, dummy return to avoid compiler warning 327| 18.3k| } _ZN4epee13serialization23throwable_buffer_reader24load_storage_array_entryEh: 213| 53.0k| { 214| 53.0k| RECURSION_LIMITATION(); ------------------ | | 104| 53.0k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 215| 53.0k| type &= ~SERIALIZE_FLAG_ARRAY; ------------------ | | 66| 53.0k|#define SERIALIZE_FLAG_ARRAY 0x80 ------------------ 216| 53.0k| switch(type) 217| 53.0k| { 218| 989| case SERIALIZE_TYPE_INT64: return read_ae(); ------------------ | | 52| 989|#define SERIALIZE_TYPE_INT64 1 ------------------ | Branch (218:7): [True: 989, False: 52.0k] ------------------ 219| 1.50k| case SERIALIZE_TYPE_INT32: return read_ae(); ------------------ | | 53| 1.50k|#define SERIALIZE_TYPE_INT32 2 ------------------ | Branch (219:7): [True: 1.50k, False: 51.5k] ------------------ 220| 4.30k| case SERIALIZE_TYPE_INT16: return read_ae(); ------------------ | | 54| 4.30k|#define SERIALIZE_TYPE_INT16 3 ------------------ | Branch (220:7): [True: 4.30k, False: 48.7k] ------------------ 221| 1.28k| case SERIALIZE_TYPE_INT8: return read_ae(); ------------------ | | 55| 1.28k|#define SERIALIZE_TYPE_INT8 4 ------------------ | Branch (221:7): [True: 1.28k, False: 51.7k] ------------------ 222| 905| case SERIALIZE_TYPE_UINT64: return read_ae(); ------------------ | | 56| 905|#define SERIALIZE_TYPE_UINT64 5 ------------------ | Branch (222:7): [True: 905, False: 52.1k] ------------------ 223| 925| case SERIALIZE_TYPE_UINT32: return read_ae(); ------------------ | | 57| 925|#define SERIALIZE_TYPE_UINT32 6 ------------------ | Branch (223:7): [True: 925, False: 52.0k] ------------------ 224| 4.51k| case SERIALIZE_TYPE_UINT16: return read_ae(); ------------------ | | 58| 4.51k|#define SERIALIZE_TYPE_UINT16 7 ------------------ | Branch (224:7): [True: 4.51k, False: 48.4k] ------------------ 225| 1.28k| case SERIALIZE_TYPE_UINT8: return read_ae(); ------------------ | | 59| 1.28k|#define SERIALIZE_TYPE_UINT8 8 ------------------ | Branch (225:7): [True: 1.28k, False: 51.7k] ------------------ 226| 1.50k| case SERIALIZE_TYPE_DOUBLE: return read_ae(); ------------------ | | 60| 1.50k|#define SERIALIZE_TYPE_DOUBLE 9 ------------------ | Branch (226:7): [True: 1.50k, False: 51.5k] ------------------ 227| 5.73k| case SERIALIZE_TYPE_BOOL: return read_ae(); ------------------ | | 62| 5.73k|#define SERIALIZE_TYPE_BOOL 11 ------------------ | Branch (227:7): [True: 5.73k, False: 47.2k] ------------------ 228| 14.6k| case SERIALIZE_TYPE_STRING: return read_ae(); ------------------ | | 61| 14.6k|#define SERIALIZE_TYPE_STRING 10 ------------------ | Branch (228:7): [True: 14.6k, False: 38.3k] ------------------ 229| 13.6k| case SERIALIZE_TYPE_OBJECT: return read_ae
(); ------------------ | | 63| 13.6k|#define SERIALIZE_TYPE_OBJECT 12 ------------------ | Branch (229:7): [True: 13.6k, False: 39.3k] ------------------ 230| 1.74k| case SERIALIZE_TYPE_ARRAY: return read_ae(); ------------------ | | 64| 1.74k|#define SERIALIZE_TYPE_ARRAY 13 ------------------ | Branch (230:7): [True: 1.74k, False: 51.2k] ------------------ 231| 38| default: ------------------ | Branch (231:7): [True: 38, False: 52.9k] ------------------ 232| 38| CHECK_AND_ASSERT_THROW_MES(false, "unknown entry_type code = " << type); ------------------ | | 175| 38|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 38|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 38|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 38|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 38|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 38|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 38|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 38| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 38] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 38| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [Folded - Ignored] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 233| 53.0k| } 234| 0| return read_ae(); // unreachable, dummy return to avoid compiler warning 235| 53.0k| } _ZN4epee13serialization23throwable_buffer_reader7read_aeIlEEN5boost7variantImJjthlisadbNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS0_7sectionENS4_INS3_6detail7variant14recursive_flagINS0_13array_entry_tISC_EEEEJNSG_ImEENSG_IjEENSG_ItEENSG_IhEENSG_IlEENSG_IiEENSG_IsEENSG_IaEENSG_IdEENSG_IbEENSG_ISB_EESH_NSG_INS3_18recursive_variant_EEEEEEEEEv: 187| 989| { 188| 989| RECURSION_LIMITATION(); ------------------ | | 104| 989|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 189| | //for pod types 190| 989| array_entry_t sa; 191| 989| size_t size = read_varint(); 192| 989| CHECK_AND_ASSERT_THROW_MES(size <= m_count / ps_min_bytes::strict, "Size sanity check failed"); ------------------ | | 175| 989|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 101|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 101|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 101|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 101|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 101|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 101|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 101| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 101] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 101| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 101, False: 888] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 193| 888| if (std::is_same()) ------------------ | Branch (193:11): [Folded - Ignored] ------------------ 194| 0| { 195| 0| CHECK_AND_ASSERT_THROW_MES(size <= max_objects - m_objects, "Too many objects"); ------------------ | | 175| 0|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 0, False: 0] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 196| 0| m_objects += size; 197| 0| } 198| 888| else if (std::is_same()) ------------------ | Branch (198:16): [Folded - Ignored] ------------------ 199| 0| { 200| 0| CHECK_AND_ASSERT_THROW_MES(size <= max_strings - m_strings, "Too many strings"); ------------------ | | 175| 0|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 0, False: 0] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 201| 0| m_strings += size; 202| 0| } 203| | 204| 888| sa.reserve(size); 205| | //TODO: add some optimization here later 206| 135k| while(size--) ------------------ | Branch (206:13): [True: 134k, False: 888] ------------------ 207| 134k| sa.m_array.push_back(read()); 208| 888| return storage_entry(array_entry(std::move(sa))); 209| 888| } _ZN4epee13serialization23throwable_buffer_reader4readIlEET_v: 177| 134k| { 178| 134k| RECURSION_LIMITATION(); ------------------ | | 104| 134k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 179| 134k| t_type v; 180| 134k| read(v); 181| 134k| return v; 182| 134k| } _ZN4epee13serialization23throwable_buffer_reader4readIlEEvRT_: 156| 136k| { 157| 136k| RECURSION_LIMITATION(); ------------------ | | 104| 136k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 158| 136k| static_assert(std::is_pod::value, "POD type expected"); 159| 136k| read(&pod_val, sizeof(pod_val)); 160| 136k| pod_val = CONVERT_POD(pod_val); ------------------ | | 45| 136k|#define CONVERT_POD(x) (x) ------------------ 161| 136k| } _ZN4epee13serialization23throwable_buffer_reader7read_aeIiEEN5boost7variantImJjthlisadbNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS0_7sectionENS4_INS3_6detail7variant14recursive_flagINS0_13array_entry_tISC_EEEEJNSG_ImEENSG_IjEENSG_ItEENSG_IhEENSG_IlEENSG_IiEENSG_IsEENSG_IaEENSG_IdEENSG_IbEENSG_ISB_EESH_NSG_INS3_18recursive_variant_EEEEEEEEEv: 187| 1.50k| { 188| 1.50k| RECURSION_LIMITATION(); ------------------ | | 104| 1.50k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 189| | //for pod types 190| 1.50k| array_entry_t sa; 191| 1.50k| size_t size = read_varint(); 192| 1.50k| CHECK_AND_ASSERT_THROW_MES(size <= m_count / ps_min_bytes::strict, "Size sanity check failed"); ------------------ | | 175| 1.50k|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 105|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 105|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 105|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 105|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 105|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 105|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 105| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 105] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 105| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 105, False: 1.39k] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 193| 1.39k| if (std::is_same()) ------------------ | Branch (193:11): [Folded - Ignored] ------------------ 194| 0| { 195| 0| CHECK_AND_ASSERT_THROW_MES(size <= max_objects - m_objects, "Too many objects"); ------------------ | | 175| 0|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 0, False: 0] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 196| 0| m_objects += size; 197| 0| } 198| 1.39k| else if (std::is_same()) ------------------ | Branch (198:16): [Folded - Ignored] ------------------ 199| 0| { 200| 0| CHECK_AND_ASSERT_THROW_MES(size <= max_strings - m_strings, "Too many strings"); ------------------ | | 175| 0|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 0, False: 0] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 201| 0| m_strings += size; 202| 0| } 203| | 204| 1.39k| sa.reserve(size); 205| | //TODO: add some optimization here later 206| 265k| while(size--) ------------------ | Branch (206:13): [True: 264k, False: 1.39k] ------------------ 207| 264k| sa.m_array.push_back(read()); 208| 1.39k| return storage_entry(array_entry(std::move(sa))); 209| 1.39k| } _ZN4epee13serialization23throwable_buffer_reader4readIiEET_v: 177| 264k| { 178| 264k| RECURSION_LIMITATION(); ------------------ | | 104| 264k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 179| 264k| t_type v; 180| 264k| read(v); 181| 264k| return v; 182| 264k| } _ZN4epee13serialization23throwable_buffer_reader4readIiEEvRT_: 156| 264k| { 157| 264k| RECURSION_LIMITATION(); ------------------ | | 104| 264k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 158| 264k| static_assert(std::is_pod::value, "POD type expected"); 159| 264k| read(&pod_val, sizeof(pod_val)); 160| 264k| pod_val = CONVERT_POD(pod_val); ------------------ | | 45| 264k|#define CONVERT_POD(x) (x) ------------------ 161| 264k| } _ZN4epee13serialization23throwable_buffer_reader7read_aeIsEEN5boost7variantImJjthlisadbNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS0_7sectionENS4_INS3_6detail7variant14recursive_flagINS0_13array_entry_tISC_EEEEJNSG_ImEENSG_IjEENSG_ItEENSG_IhEENSG_IlEENSG_IiEENSG_IsEENSG_IaEENSG_IdEENSG_IbEENSG_ISB_EESH_NSG_INS3_18recursive_variant_EEEEEEEEEv: 187| 4.30k| { 188| 4.30k| RECURSION_LIMITATION(); ------------------ | | 104| 4.30k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 189| | //for pod types 190| 4.30k| array_entry_t sa; 191| 4.30k| size_t size = read_varint(); 192| 4.30k| CHECK_AND_ASSERT_THROW_MES(size <= m_count / ps_min_bytes::strict, "Size sanity check failed"); ------------------ | | 175| 4.30k|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 99|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 99|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 99|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 99|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 99|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 99|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 99| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 99] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 99| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 99, False: 4.20k] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 193| 4.20k| if (std::is_same()) ------------------ | Branch (193:11): [Folded - Ignored] ------------------ 194| 0| { 195| 0| CHECK_AND_ASSERT_THROW_MES(size <= max_objects - m_objects, "Too many objects"); ------------------ | | 175| 0|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 0, False: 0] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 196| 0| m_objects += size; 197| 0| } 198| 4.20k| else if (std::is_same()) ------------------ | Branch (198:16): [Folded - Ignored] ------------------ 199| 0| { 200| 0| CHECK_AND_ASSERT_THROW_MES(size <= max_strings - m_strings, "Too many strings"); ------------------ | | 175| 0|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 0, False: 0] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 201| 0| m_strings += size; 202| 0| } 203| | 204| 4.20k| sa.reserve(size); 205| | //TODO: add some optimization here later 206| 530k| while(size--) ------------------ | Branch (206:13): [True: 525k, False: 4.20k] ------------------ 207| 525k| sa.m_array.push_back(read()); 208| 4.20k| return storage_entry(array_entry(std::move(sa))); 209| 4.20k| } _ZN4epee13serialization23throwable_buffer_reader4readIsEET_v: 177| 525k| { 178| 525k| RECURSION_LIMITATION(); ------------------ | | 104| 525k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 179| 525k| t_type v; 180| 525k| read(v); 181| 525k| return v; 182| 525k| } _ZN4epee13serialization23throwable_buffer_reader4readIsEEvRT_: 156| 526k| { 157| 526k| RECURSION_LIMITATION(); ------------------ | | 104| 526k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 158| 526k| static_assert(std::is_pod::value, "POD type expected"); 159| 526k| read(&pod_val, sizeof(pod_val)); 160| 526k| pod_val = CONVERT_POD(pod_val); ------------------ | | 45| 526k|#define CONVERT_POD(x) (x) ------------------ 161| 526k| } _ZN4epee13serialization23throwable_buffer_reader7read_aeIaEEN5boost7variantImJjthlisadbNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS0_7sectionENS4_INS3_6detail7variant14recursive_flagINS0_13array_entry_tISC_EEEEJNSG_ImEENSG_IjEENSG_ItEENSG_IhEENSG_IlEENSG_IiEENSG_IsEENSG_IaEENSG_IdEENSG_IbEENSG_ISB_EESH_NSG_INS3_18recursive_variant_EEEEEEEEEv: 187| 1.28k| { 188| 1.28k| RECURSION_LIMITATION(); ------------------ | | 104| 1.28k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 189| | //for pod types 190| 1.28k| array_entry_t sa; 191| 1.28k| size_t size = read_varint(); 192| 1.28k| CHECK_AND_ASSERT_THROW_MES(size <= m_count / ps_min_bytes::strict, "Size sanity check failed"); ------------------ | | 175| 1.28k|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 98|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 98|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 98|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 98|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 98|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 98|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 98| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 98] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 98| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 98, False: 1.18k] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 193| 1.18k| if (std::is_same()) ------------------ | Branch (193:11): [Folded - Ignored] ------------------ 194| 0| { 195| 0| CHECK_AND_ASSERT_THROW_MES(size <= max_objects - m_objects, "Too many objects"); ------------------ | | 175| 0|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 0, False: 0] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 196| 0| m_objects += size; 197| 0| } 198| 1.18k| else if (std::is_same()) ------------------ | Branch (198:16): [Folded - Ignored] ------------------ 199| 0| { 200| 0| CHECK_AND_ASSERT_THROW_MES(size <= max_strings - m_strings, "Too many strings"); ------------------ | | 175| 0|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 0, False: 0] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 201| 0| m_strings += size; 202| 0| } 203| | 204| 1.18k| sa.reserve(size); 205| | //TODO: add some optimization here later 206| 1.05M| while(size--) ------------------ | Branch (206:13): [True: 1.05M, False: 1.18k] ------------------ 207| 1.05M| sa.m_array.push_back(read()); 208| 1.18k| return storage_entry(array_entry(std::move(sa))); 209| 1.18k| } _ZN4epee13serialization23throwable_buffer_reader4readIaEET_v: 177| 1.05M| { 178| 1.05M| RECURSION_LIMITATION(); ------------------ | | 104| 1.05M|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 179| 1.05M| t_type v; 180| 1.05M| read(v); 181| 1.05M| return v; 182| 1.05M| } _ZN4epee13serialization23throwable_buffer_reader4readIaEEvRT_: 156| 1.05M| { 157| 1.05M| RECURSION_LIMITATION(); ------------------ | | 104| 1.05M|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 158| 1.05M| static_assert(std::is_pod::value, "POD type expected"); 159| 1.05M| read(&pod_val, sizeof(pod_val)); 160| 1.05M| pod_val = CONVERT_POD(pod_val); ------------------ | | 45| 1.05M|#define CONVERT_POD(x) (x) ------------------ 161| 1.05M| } _ZN4epee13serialization23throwable_buffer_reader7read_aeImEEN5boost7variantImJjthlisadbNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS0_7sectionENS4_INS3_6detail7variant14recursive_flagINS0_13array_entry_tISC_EEEEJNSG_ImEENSG_IjEENSG_ItEENSG_IhEENSG_IlEENSG_IiEENSG_IsEENSG_IaEENSG_IdEENSG_IbEENSG_ISB_EESH_NSG_INS3_18recursive_variant_EEEEEEEEEv: 187| 905| { 188| 905| RECURSION_LIMITATION(); ------------------ | | 104| 905|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 189| | //for pod types 190| 905| array_entry_t sa; 191| 905| size_t size = read_varint(); 192| 905| CHECK_AND_ASSERT_THROW_MES(size <= m_count / ps_min_bytes::strict, "Size sanity check failed"); ------------------ | | 175| 905|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 104|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 104|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 104|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 104|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 104|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 104|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 104| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 104] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 104| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 104, False: 801] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 193| 801| if (std::is_same()) ------------------ | Branch (193:11): [Folded - Ignored] ------------------ 194| 0| { 195| 0| CHECK_AND_ASSERT_THROW_MES(size <= max_objects - m_objects, "Too many objects"); ------------------ | | 175| 0|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 0, False: 0] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 196| 0| m_objects += size; 197| 0| } 198| 801| else if (std::is_same()) ------------------ | Branch (198:16): [Folded - Ignored] ------------------ 199| 0| { 200| 0| CHECK_AND_ASSERT_THROW_MES(size <= max_strings - m_strings, "Too many strings"); ------------------ | | 175| 0|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 0, False: 0] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 201| 0| m_strings += size; 202| 0| } 203| | 204| 801| sa.reserve(size); 205| | //TODO: add some optimization here later 206| 178k| while(size--) ------------------ | Branch (206:13): [True: 177k, False: 801] ------------------ 207| 177k| sa.m_array.push_back(read()); 208| 801| return storage_entry(array_entry(std::move(sa))); 209| 801| } _ZN4epee13serialization23throwable_buffer_reader7read_aeIjEEN5boost7variantImJjthlisadbNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS0_7sectionENS4_INS3_6detail7variant14recursive_flagINS0_13array_entry_tISC_EEEEJNSG_ImEENSG_IjEENSG_ItEENSG_IhEENSG_IlEENSG_IiEENSG_IsEENSG_IaEENSG_IdEENSG_IbEENSG_ISB_EESH_NSG_INS3_18recursive_variant_EEEEEEEEEv: 187| 925| { 188| 925| RECURSION_LIMITATION(); ------------------ | | 104| 925|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 189| | //for pod types 190| 925| array_entry_t sa; 191| 925| size_t size = read_varint(); 192| 925| CHECK_AND_ASSERT_THROW_MES(size <= m_count / ps_min_bytes::strict, "Size sanity check failed"); ------------------ | | 175| 925|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 99|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 99|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 99|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 99|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 99|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 99|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 99| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 99] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 99| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 99, False: 826] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 193| 826| if (std::is_same()) ------------------ | Branch (193:11): [Folded - Ignored] ------------------ 194| 0| { 195| 0| CHECK_AND_ASSERT_THROW_MES(size <= max_objects - m_objects, "Too many objects"); ------------------ | | 175| 0|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 0, False: 0] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 196| 0| m_objects += size; 197| 0| } 198| 826| else if (std::is_same()) ------------------ | Branch (198:16): [Folded - Ignored] ------------------ 199| 0| { 200| 0| CHECK_AND_ASSERT_THROW_MES(size <= max_strings - m_strings, "Too many strings"); ------------------ | | 175| 0|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 0, False: 0] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 201| 0| m_strings += size; 202| 0| } 203| | 204| 826| sa.reserve(size); 205| | //TODO: add some optimization here later 206| 265k| while(size--) ------------------ | Branch (206:13): [True: 265k, False: 826] ------------------ 207| 265k| sa.m_array.push_back(read()); 208| 826| return storage_entry(array_entry(std::move(sa))); 209| 826| } _ZN4epee13serialization23throwable_buffer_reader7read_aeItEEN5boost7variantImJjthlisadbNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS0_7sectionENS4_INS3_6detail7variant14recursive_flagINS0_13array_entry_tISC_EEEEJNSG_ImEENSG_IjEENSG_ItEENSG_IhEENSG_IlEENSG_IiEENSG_IsEENSG_IaEENSG_IdEENSG_IbEENSG_ISB_EESH_NSG_INS3_18recursive_variant_EEEEEEEEEv: 187| 4.51k| { 188| 4.51k| RECURSION_LIMITATION(); ------------------ | | 104| 4.51k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 189| | //for pod types 190| 4.51k| array_entry_t sa; 191| 4.51k| size_t size = read_varint(); 192| 4.51k| CHECK_AND_ASSERT_THROW_MES(size <= m_count / ps_min_bytes::strict, "Size sanity check failed"); ------------------ | | 175| 4.51k|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 98|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 98|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 98|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 98|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 98|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 98|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 98| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 98] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 98| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 98, False: 4.42k] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 193| 4.42k| if (std::is_same()) ------------------ | Branch (193:11): [Folded - Ignored] ------------------ 194| 0| { 195| 0| CHECK_AND_ASSERT_THROW_MES(size <= max_objects - m_objects, "Too many objects"); ------------------ | | 175| 0|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 0, False: 0] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 196| 0| m_objects += size; 197| 0| } 198| 4.42k| else if (std::is_same()) ------------------ | Branch (198:16): [Folded - Ignored] ------------------ 199| 0| { 200| 0| CHECK_AND_ASSERT_THROW_MES(size <= max_strings - m_strings, "Too many strings"); ------------------ | | 175| 0|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 0, False: 0] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 201| 0| m_strings += size; 202| 0| } 203| | 204| 4.42k| sa.reserve(size); 205| | //TODO: add some optimization here later 206| 660k| while(size--) ------------------ | Branch (206:13): [True: 656k, False: 4.42k] ------------------ 207| 656k| sa.m_array.push_back(read()); 208| 4.42k| return storage_entry(array_entry(std::move(sa))); 209| 4.42k| } _ZN4epee13serialization23throwable_buffer_reader7read_aeIhEEN5boost7variantImJjthlisadbNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS0_7sectionENS4_INS3_6detail7variant14recursive_flagINS0_13array_entry_tISC_EEEEJNSG_ImEENSG_IjEENSG_ItEENSG_IhEENSG_IlEENSG_IiEENSG_IsEENSG_IaEENSG_IdEENSG_IbEENSG_ISB_EESH_NSG_INS3_18recursive_variant_EEEEEEEEEv: 187| 1.28k| { 188| 1.28k| RECURSION_LIMITATION(); ------------------ | | 104| 1.28k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 189| | //for pod types 190| 1.28k| array_entry_t sa; 191| 1.28k| size_t size = read_varint(); 192| 1.28k| CHECK_AND_ASSERT_THROW_MES(size <= m_count / ps_min_bytes::strict, "Size sanity check failed"); ------------------ | | 175| 1.28k|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 67|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 67|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 67|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 67|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 67|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 67|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 67| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 67] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 67| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 67, False: 1.21k] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 193| 1.21k| if (std::is_same()) ------------------ | Branch (193:11): [Folded - Ignored] ------------------ 194| 0| { 195| 0| CHECK_AND_ASSERT_THROW_MES(size <= max_objects - m_objects, "Too many objects"); ------------------ | | 175| 0|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 0, False: 0] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 196| 0| m_objects += size; 197| 0| } 198| 1.21k| else if (std::is_same()) ------------------ | Branch (198:16): [Folded - Ignored] ------------------ 199| 0| { 200| 0| CHECK_AND_ASSERT_THROW_MES(size <= max_strings - m_strings, "Too many strings"); ------------------ | | 175| 0|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 0, False: 0] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 201| 0| m_strings += size; 202| 0| } 203| | 204| 1.21k| sa.reserve(size); 205| | //TODO: add some optimization here later 206| 1.05M| while(size--) ------------------ | Branch (206:13): [True: 1.05M, False: 1.21k] ------------------ 207| 1.05M| sa.m_array.push_back(read()); 208| 1.21k| return storage_entry(array_entry(std::move(sa))); 209| 1.21k| } _ZN4epee13serialization23throwable_buffer_reader7read_aeIdEEN5boost7variantImJjthlisadbNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS0_7sectionENS4_INS3_6detail7variant14recursive_flagINS0_13array_entry_tISC_EEEEJNSG_ImEENSG_IjEENSG_ItEENSG_IhEENSG_IlEENSG_IiEENSG_IsEENSG_IaEENSG_IdEENSG_IbEENSG_ISB_EESH_NSG_INS3_18recursive_variant_EEEEEEEEEv: 187| 1.50k| { 188| 1.50k| RECURSION_LIMITATION(); ------------------ | | 104| 1.50k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 189| | //for pod types 190| 1.50k| array_entry_t sa; 191| 1.50k| size_t size = read_varint(); 192| 1.50k| CHECK_AND_ASSERT_THROW_MES(size <= m_count / ps_min_bytes::strict, "Size sanity check failed"); ------------------ | | 175| 1.50k|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 102|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 102|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 102|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 102|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 102|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 102|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 102| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 102] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 102| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 102, False: 1.39k] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 193| 1.39k| if (std::is_same()) ------------------ | Branch (193:11): [Folded - Ignored] ------------------ 194| 0| { 195| 0| CHECK_AND_ASSERT_THROW_MES(size <= max_objects - m_objects, "Too many objects"); ------------------ | | 175| 0|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 0, False: 0] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 196| 0| m_objects += size; 197| 0| } 198| 1.39k| else if (std::is_same()) ------------------ | Branch (198:16): [Folded - Ignored] ------------------ 199| 0| { 200| 0| CHECK_AND_ASSERT_THROW_MES(size <= max_strings - m_strings, "Too many strings"); ------------------ | | 175| 0|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 0, False: 0] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 201| 0| m_strings += size; 202| 0| } 203| | 204| 1.39k| sa.reserve(size); 205| | //TODO: add some optimization here later 206| 198k| while(size--) ------------------ | Branch (206:13): [True: 197k, False: 1.39k] ------------------ 207| 197k| sa.m_array.push_back(read()); 208| 1.39k| return storage_entry(array_entry(std::move(sa))); 209| 1.39k| } _ZN4epee13serialization23throwable_buffer_reader4readIdEET_v: 177| 197k| { 178| 197k| RECURSION_LIMITATION(); ------------------ | | 104| 197k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 179| 197k| t_type v; 180| 197k| read(v); 181| 197k| return v; 182| 197k| } _ZN4epee13serialization23throwable_buffer_reader4readIdEEvRT_: 156| 197k| { 157| 197k| RECURSION_LIMITATION(); ------------------ | | 104| 197k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 158| 197k| static_assert(std::is_pod::value, "POD type expected"); 159| 197k| read(&pod_val, sizeof(pod_val)); 160| 197k| pod_val = CONVERT_POD(pod_val); ------------------ | | 45| 197k|#define CONVERT_POD(x) (x) ------------------ 161| 197k| } _ZN4epee13serialization23throwable_buffer_reader7read_aeIbEEN5boost7variantImJjthlisadbNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS0_7sectionENS4_INS3_6detail7variant14recursive_flagINS0_13array_entry_tISC_EEEEJNSG_ImEENSG_IjEENSG_ItEENSG_IhEENSG_IlEENSG_IiEENSG_IsEENSG_IaEENSG_IdEENSG_IbEENSG_ISB_EESH_NSG_INS3_18recursive_variant_EEEEEEEEEv: 187| 5.73k| { 188| 5.73k| RECURSION_LIMITATION(); ------------------ | | 104| 5.73k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 189| | //for pod types 190| 5.73k| array_entry_t sa; 191| 5.73k| size_t size = read_varint(); 192| 5.73k| CHECK_AND_ASSERT_THROW_MES(size <= m_count / ps_min_bytes::strict, "Size sanity check failed"); ------------------ | | 175| 5.73k|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 106|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 106|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 106|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 106|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 106|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 106|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 106| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 106] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 106| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 106, False: 5.62k] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 193| 5.62k| if (std::is_same()) ------------------ | Branch (193:11): [Folded - Ignored] ------------------ 194| 0| { 195| 0| CHECK_AND_ASSERT_THROW_MES(size <= max_objects - m_objects, "Too many objects"); ------------------ | | 175| 0|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 0, False: 0] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 196| 0| m_objects += size; 197| 0| } 198| 5.62k| else if (std::is_same()) ------------------ | Branch (198:16): [Folded - Ignored] ------------------ 199| 0| { 200| 0| CHECK_AND_ASSERT_THROW_MES(size <= max_strings - m_strings, "Too many strings"); ------------------ | | 175| 0|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 0, False: 0] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 201| 0| m_strings += size; 202| 0| } 203| | 204| 5.62k| sa.reserve(size); 205| | //TODO: add some optimization here later 206| 14.7M| while(size--) ------------------ | Branch (206:13): [True: 14.7M, False: 5.62k] ------------------ 207| 14.7M| sa.m_array.push_back(read()); 208| 5.62k| return storage_entry(array_entry(std::move(sa))); 209| 5.62k| } _ZN4epee13serialization23throwable_buffer_reader4readIbEET_v: 177| 14.7M| { 178| 14.7M| RECURSION_LIMITATION(); ------------------ | | 104| 14.7M|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 179| 14.7M| t_type v; 180| 14.7M| read(v); 181| 14.7M| return v; 182| 14.7M| } _ZN4epee13serialization23throwable_buffer_reader7read_aeINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEN5boost7variantImJjthlisadbS9_NS0_7sectionENSB_INSA_6detail7variant14recursive_flagINS0_13array_entry_tISC_EEEEJNSG_ImEENSG_IjEENSG_ItEENSG_IhEENSG_IlEENSG_IiEENSG_IsEENSG_IaEENSG_IdEENSG_IbEENSG_IS9_EESH_NSG_INSA_18recursive_variant_EEEEEEEEEv: 187| 14.6k| { 188| 14.6k| RECURSION_LIMITATION(); ------------------ | | 104| 14.6k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 189| | //for pod types 190| 14.6k| array_entry_t sa; 191| 14.6k| size_t size = read_varint(); 192| 14.6k| CHECK_AND_ASSERT_THROW_MES(size <= m_count / ps_min_bytes::strict, "Size sanity check failed"); ------------------ | | 175| 14.6k|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 112|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 112|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 112|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 112|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 112|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 112|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 112| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 112] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 112| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 112, False: 14.5k] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 193| 14.5k| if (std::is_same()) ------------------ | Branch (193:11): [Folded - Ignored] ------------------ 194| 0| { 195| 0| CHECK_AND_ASSERT_THROW_MES(size <= max_objects - m_objects, "Too many objects"); ------------------ | | 175| 0|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 0, False: 0] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 196| 0| m_objects += size; 197| 0| } 198| 14.5k| else if (std::is_same()) ------------------ | Branch (198:16): [Folded - Ignored] ------------------ 199| 14.5k| { 200| 14.5k| CHECK_AND_ASSERT_THROW_MES(size <= max_strings - m_strings, "Too many strings"); ------------------ | | 175| 14.5k|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 0, False: 14.5k] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 201| 14.5k| m_strings += size; 202| 14.5k| } 203| | 204| 14.5k| sa.reserve(size); 205| | //TODO: add some optimization here later 206| 3.88M| while(size--) ------------------ | Branch (206:13): [True: 3.86M, False: 14.5k] ------------------ 207| 3.86M| sa.m_array.push_back(read()); 208| 14.5k| return storage_entry(array_entry(std::move(sa))); 209| 14.5k| } _ZN4epee13serialization23throwable_buffer_reader4readINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEET_v: 177| 3.86M| { 178| 3.86M| RECURSION_LIMITATION(); ------------------ | | 104| 3.86M|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 179| 3.86M| t_type v; 180| 3.86M| read(v); 181| 3.86M| return v; 182| 3.86M| } _ZN4epee13serialization23throwable_buffer_reader4readERNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 348| 3.86M| { 349| 3.86M| RECURSION_LIMITATION(); ------------------ | | 104| 3.86M|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 350| 3.86M| size_t len = read_varint(); 351| 3.86M| CHECK_AND_ASSERT_THROW_MES(len < MAX_STRING_LEN_POSSIBLE, "to big string len value in storage: " << len); ------------------ | | 175| 3.86M|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 45|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 45|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 45|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 45|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 45|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 45|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 45| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 45] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 45| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 45, False: 3.86M] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 352| 3.86M| CHECK_AND_ASSERT_THROW_MES(m_count >= len, "string len count value " << len << " goes out of remain storage len " << m_count); ------------------ | | 175| 3.86M|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 110|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 110|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 110|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 110|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 110|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 110|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 110| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 110] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 110| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 110, False: 3.86M] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 353| | //do this manually to avoid double memory write in huge strings (first time at resize, second at read) 354| 3.86M| str.assign((const char*)m_ptr, len); 355| 3.86M| m_ptr+=len; 356| 3.86M| m_count -= len; 357| 3.86M| } _ZN4epee13serialization23throwable_buffer_reader7read_aeINS0_7sectionEEEN5boost7variantImJjthlisadbNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEES3_NS5_INS4_6detail7variant14recursive_flagINS0_13array_entry_tIS3_EEEEJNSG_ImEENSG_IjEENSG_ItEENSG_IhEENSG_IlEENSG_IiEENSG_IsEENSG_IaEENSG_IdEENSG_IbEENSG_ISC_EESH_NSG_INS4_18recursive_variant_EEEEEEEEEv: 187| 13.6k| { 188| 13.6k| RECURSION_LIMITATION(); ------------------ | | 104| 13.6k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 189| | //for pod types 190| 13.6k| array_entry_t sa; 191| 13.6k| size_t size = read_varint(); 192| 13.6k| CHECK_AND_ASSERT_THROW_MES(size <= m_count / ps_min_bytes::strict, "Size sanity check failed"); ------------------ | | 175| 13.6k|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 105|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 105|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 105|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 105|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 105|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 105|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 105| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 105] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 105| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 105, False: 13.5k] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 193| 13.5k| if (std::is_same()) ------------------ | Branch (193:11): [Folded - Ignored] ------------------ 194| 13.5k| { 195| 13.5k| CHECK_AND_ASSERT_THROW_MES(size <= max_objects - m_objects, "Too many objects"); ------------------ | | 175| 13.5k|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 0, False: 13.5k] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 196| 13.5k| m_objects += size; 197| 13.5k| } 198| 21| else if (std::is_same()) ------------------ | Branch (198:16): [Folded - Ignored] ------------------ 199| 0| { 200| 0| CHECK_AND_ASSERT_THROW_MES(size <= max_strings - m_strings, "Too many strings"); ------------------ | | 175| 0|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 0, False: 0] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 201| 0| m_strings += size; 202| 0| } 203| | 204| 13.5k| sa.reserve(size); 205| | //TODO: add some optimization here later 206| 1.07M| while(size--) ------------------ | Branch (206:13): [True: 1.06M, False: 13.5k] ------------------ 207| 1.06M| sa.m_array.push_back(read()); 208| 13.5k| return storage_entry(array_entry(std::move(sa))); 209| 13.5k| } _ZN4epee13serialization23throwable_buffer_reader4readINS0_7sectionEEET_v: 177| 1.06M| { 178| 1.06M| RECURSION_LIMITATION(); ------------------ | | 104| 1.06M|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 179| 1.06M| t_type v; 180| 1.06M| read(v); 181| 1.06M| return v; 182| 1.06M| } _ZN4epee13serialization23throwable_buffer_reader7read_aeIN5boost7variantINS3_6detail7variant14recursive_flagINS0_13array_entry_tINS0_7sectionEEEEEJNS8_ImEENS8_IjEENS8_ItEENS8_IhEENS8_IlEENS8_IiEENS8_IsEENS8_IaEENS8_IdEENS8_IbEENS8_INSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEESA_NS8_INS3_18recursive_variant_EEEEEEEENS4_ImJjthlisadbSS_S9_SW_EEEv: 187| 1.74k| { 188| 1.74k| RECURSION_LIMITATION(); ------------------ | | 104| 1.74k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 189| | //for pod types 190| 1.74k| array_entry_t sa; 191| 1.74k| size_t size = read_varint(); 192| 1.74k| CHECK_AND_ASSERT_THROW_MES(size <= m_count / ps_min_bytes::strict, "Size sanity check failed"); ------------------ | | 175| 1.74k|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 98|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 98|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 98|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 98|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 98|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 98|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 98| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 98] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 98| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 98, False: 1.64k] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 193| 1.64k| if (std::is_same()) ------------------ | Branch (193:11): [Folded - Ignored] ------------------ 194| 0| { 195| 0| CHECK_AND_ASSERT_THROW_MES(size <= max_objects - m_objects, "Too many objects"); ------------------ | | 175| 0|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 0, False: 0] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 196| 0| m_objects += size; 197| 0| } 198| 1.64k| else if (std::is_same()) ------------------ | Branch (198:16): [Folded - Ignored] ------------------ 199| 0| { 200| 0| CHECK_AND_ASSERT_THROW_MES(size <= max_strings - m_strings, "Too many strings"); ------------------ | | 175| 0|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 0, False: 0] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 201| 0| m_strings += size; 202| 0| } 203| | 204| 1.64k| sa.reserve(size); 205| | //TODO: add some optimization here later 206| 1.68k| while(size--) ------------------ | Branch (206:13): [True: 33, False: 1.64k] ------------------ 207| 33| sa.m_array.push_back(read()); 208| 1.64k| return storage_entry(array_entry(std::move(sa))); 209| 1.64k| } _ZN4epee13serialization23throwable_buffer_reader4readIN5boost7variantINS3_6detail7variant14recursive_flagINS0_13array_entry_tINS0_7sectionEEEEEJNS8_ImEENS8_IjEENS8_ItEENS8_IhEENS8_IlEENS8_IiEENS8_IsEENS8_IaEENS8_IdEENS8_IbEENS8_INSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEESA_NS8_INS3_18recursive_variant_EEEEEEEET_v: 177| 33| { 178| 33| RECURSION_LIMITATION(); ------------------ | | 104| 33|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 179| 33| t_type v; 180| 33| read(v); 181| 33| return v; 182| 33| } _ZN4epee13serialization23throwable_buffer_reader4readERN5boost7variantINS2_6detail7variant14recursive_flagINS0_13array_entry_tINS0_7sectionEEEEEJNS7_ImEENS7_IjEENS7_ItEENS7_IhEENS7_IlEENS7_IiEENS7_IsEENS7_IaEENS7_IdEENS7_IbEENS7_INSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEES9_NS7_INS2_18recursive_variant_EEEEEE: 360| 33| { 361| 33| RECURSION_LIMITATION(); ------------------ | | 104| 33|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 362| 33| CHECK_AND_ASSERT_THROW_MES(false, "Reading array entry is not supported"); ------------------ | | 175| 33|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 33|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 33|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 33|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 33|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 33|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 33|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 33| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 33] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 33| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [Folded - Ignored] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 363| 33| } _ZN4epee13serialization23throwable_buffer_reader7read_seIlEEN5boost7variantImJjthlisadbNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS0_7sectionENS4_INS3_6detail7variant14recursive_flagINS0_13array_entry_tISC_EEEEJNSG_ImEENSG_IjEENSG_ItEENSG_IhEENSG_IlEENSG_IiEENSG_IsEENSG_IaEENSG_IdEENSG_IbEENSG_ISB_EESH_NSG_INS3_18recursive_variant_EEEEEEEEEv: 259| 2.26k| { 260| 2.26k| RECURSION_LIMITATION(); ------------------ | | 104| 2.26k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 261| 2.26k| t_type v; 262| 2.26k| read(v); 263| 2.26k| return storage_entry(v); 264| 2.26k| } _ZN4epee13serialization23throwable_buffer_reader7read_seIiEEN5boost7variantImJjthlisadbNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS0_7sectionENS4_INS3_6detail7variant14recursive_flagINS0_13array_entry_tISC_EEEEJNSG_ImEENSG_IjEENSG_ItEENSG_IhEENSG_IlEENSG_IiEENSG_IsEENSG_IaEENSG_IdEENSG_IbEENSG_ISB_EESH_NSG_INS3_18recursive_variant_EEEEEEEEEv: 259| 683| { 260| 683| RECURSION_LIMITATION(); ------------------ | | 104| 683|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 261| 683| t_type v; 262| 683| read(v); 263| 683| return storage_entry(v); 264| 683| } _ZN4epee13serialization23throwable_buffer_reader7read_seIsEEN5boost7variantImJjthlisadbNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS0_7sectionENS4_INS3_6detail7variant14recursive_flagINS0_13array_entry_tISC_EEEEJNSG_ImEENSG_IjEENSG_ItEENSG_IhEENSG_IlEENSG_IiEENSG_IsEENSG_IaEENSG_IdEENSG_IbEENSG_ISB_EESH_NSG_INS3_18recursive_variant_EEEEEEEEEv: 259| 488| { 260| 488| RECURSION_LIMITATION(); ------------------ | | 104| 488|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 261| 488| t_type v; 262| 488| read(v); 263| 488| return storage_entry(v); 264| 488| } _ZN4epee13serialization23throwable_buffer_reader7read_seIaEEN5boost7variantImJjthlisadbNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS0_7sectionENS4_INS3_6detail7variant14recursive_flagINS0_13array_entry_tISC_EEEEJNSG_ImEENSG_IjEENSG_ItEENSG_IhEENSG_IlEENSG_IiEENSG_IsEENSG_IaEENSG_IdEENSG_IbEENSG_ISB_EESH_NSG_INS3_18recursive_variant_EEEEEEEEEv: 259| 4.11k| { 260| 4.11k| RECURSION_LIMITATION(); ------------------ | | 104| 4.11k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 261| 4.11k| t_type v; 262| 4.11k| read(v); 263| 4.11k| return storage_entry(v); 264| 4.11k| } _ZN4epee13serialization23throwable_buffer_reader7read_seImEEN5boost7variantImJjthlisadbNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS0_7sectionENS4_INS3_6detail7variant14recursive_flagINS0_13array_entry_tISC_EEEEJNSG_ImEENSG_IjEENSG_ItEENSG_IhEENSG_IlEENSG_IiEENSG_IsEENSG_IaEENSG_IdEENSG_IbEENSG_ISB_EESH_NSG_INS3_18recursive_variant_EEEEEEEEEv: 259| 567| { 260| 567| RECURSION_LIMITATION(); ------------------ | | 104| 567|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 261| 567| t_type v; 262| 567| read(v); 263| 567| return storage_entry(v); 264| 567| } _ZN4epee13serialization23throwable_buffer_reader7read_seIjEEN5boost7variantImJjthlisadbNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS0_7sectionENS4_INS3_6detail7variant14recursive_flagINS0_13array_entry_tISC_EEEEJNSG_ImEENSG_IjEENSG_ItEENSG_IhEENSG_IlEENSG_IiEENSG_IsEENSG_IaEENSG_IdEENSG_IbEENSG_ISB_EESH_NSG_INS3_18recursive_variant_EEEEEEEEEv: 259| 509| { 260| 509| RECURSION_LIMITATION(); ------------------ | | 104| 509|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 261| 509| t_type v; 262| 509| read(v); 263| 509| return storage_entry(v); 264| 509| } _ZN4epee13serialization23throwable_buffer_reader7read_seItEEN5boost7variantImJjthlisadbNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS0_7sectionENS4_INS3_6detail7variant14recursive_flagINS0_13array_entry_tISC_EEEEJNSG_ImEENSG_IjEENSG_ItEENSG_IhEENSG_IlEENSG_IiEENSG_IsEENSG_IaEENSG_IdEENSG_IbEENSG_ISB_EESH_NSG_INS3_18recursive_variant_EEEEEEEEEv: 259| 368| { 260| 368| RECURSION_LIMITATION(); ------------------ | | 104| 368|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 261| 368| t_type v; 262| 368| read(v); 263| 368| return storage_entry(v); 264| 368| } _ZN4epee13serialization23throwable_buffer_reader7read_seIhEEN5boost7variantImJjthlisadbNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS0_7sectionENS4_INS3_6detail7variant14recursive_flagINS0_13array_entry_tISC_EEEEJNSG_ImEENSG_IjEENSG_ItEENSG_IhEENSG_IlEENSG_IiEENSG_IsEENSG_IaEENSG_IdEENSG_IbEENSG_ISB_EESH_NSG_INS3_18recursive_variant_EEEEEEEEEv: 259| 1.69k| { 260| 1.69k| RECURSION_LIMITATION(); ------------------ | | 104| 1.69k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 261| 1.69k| t_type v; 262| 1.69k| read(v); 263| 1.69k| return storage_entry(v); 264| 1.69k| } _ZN4epee13serialization23throwable_buffer_reader7read_seIdEEN5boost7variantImJjthlisadbNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS0_7sectionENS4_INS3_6detail7variant14recursive_flagINS0_13array_entry_tISC_EEEEJNSG_ImEENSG_IjEENSG_ItEENSG_IhEENSG_IlEENSG_IiEENSG_IsEENSG_IaEENSG_IdEENSG_IbEENSG_ISB_EESH_NSG_INS3_18recursive_variant_EEEEEEEEEv: 259| 453| { 260| 453| RECURSION_LIMITATION(); ------------------ | | 104| 453|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 261| 453| t_type v; 262| 453| read(v); 263| 453| return storage_entry(v); 264| 453| } _ZN4epee13serialization23throwable_buffer_reader7read_seIbEEN5boost7variantImJjthlisadbNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS0_7sectionENS4_INS3_6detail7variant14recursive_flagINS0_13array_entry_tISC_EEEEJNSG_ImEENSG_IjEENSG_ItEENSG_IhEENSG_IlEENSG_IiEENSG_IsEENSG_IaEENSG_IdEENSG_IbEENSG_ISB_EESH_NSG_INS3_18recursive_variant_EEEEEEEEEv: 259| 579| { 260| 579| RECURSION_LIMITATION(); ------------------ | | 104| 579|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 261| 579| t_type v; 262| 579| read(v); 263| 579| return storage_entry(v); 264| 579| } _ZN4epee13serialization23throwable_buffer_reader7read_seINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEN5boost7variantImJjthlisadbS9_NS0_7sectionENSB_INSA_6detail7variant14recursive_flagINS0_13array_entry_tISC_EEEEJNSG_ImEENSG_IjEENSG_ItEENSG_IhEENSG_IlEENSG_IiEENSG_IsEENSG_IaEENSG_IdEENSG_IbEENSG_IS9_EESH_NSG_INSA_18recursive_variant_EEEEEEEEEv: 268| 739| { 269| 739| RECURSION_LIMITATION(); ------------------ | | 104| 739|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 270| 739| CHECK_AND_ASSERT_THROW_MES(m_strings + 1 <= max_strings, "Too many strings"); ------------------ | | 175| 739|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 0, False: 739] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 271| 739| m_strings += 1; 272| 739| return storage_entry(read()); 273| 739| } _ZN4epee13serialization23throwable_buffer_reader7read_seINS0_7sectionEEEN5boost7variantImJjthlisadbNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEES3_NS5_INS4_6detail7variant14recursive_flagINS0_13array_entry_tIS3_EEEEJNSG_ImEENSG_IjEENSG_ItEENSG_IhEENSG_IlEENSG_IiEENSG_IsEENSG_IaEENSG_IdEENSG_IbEENSG_ISC_EESH_NSG_INS4_18recursive_variant_EEEEEEEEEv: 278| 4.59k| { 279| 4.59k| RECURSION_LIMITATION(); ------------------ | | 104| 4.59k|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 280| 4.59k| CHECK_AND_ASSERT_THROW_MES(m_objects < max_objects, "Too many objects"); ------------------ | | 175| 4.59k|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 0, False: 4.59k] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 281| 4.59k| ++m_objects; 282| 4.59k| section s;//use extra variable due to vs bug, line "storage_entry se(section()); " can't be compiled in visual studio 283| 4.59k| storage_entry se(std::move(s)); 284| 4.59k| section& section_entry = boost::get
(se); 285| 4.59k| read(section_entry); 286| 4.59k| return se; 287| 4.59k| } _ZN4epee13serialization23throwable_buffer_reader7read_seIN5boost7variantINS3_6detail7variant14recursive_flagINS0_13array_entry_tINS0_7sectionEEEEEJNS8_ImEENS8_IjEENS8_ItEENS8_IhEENS8_IlEENS8_IiEENS8_IsEENS8_IaEENS8_IdEENS8_IbEENS8_INSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEESA_NS8_INS3_18recursive_variant_EEEEEEEENS4_ImJjthlisadbSS_S9_SW_EEEv: 291| 940| { 292| 940| RECURSION_LIMITATION(); ------------------ | | 104| 940|#define RECURSION_LIMITATION() recursuion_limitation_guard rl(m_recursion_count) ------------------ 293| 940| uint8_t ent_type = 0; 294| 940| read(ent_type); 295| 940| CHECK_AND_ASSERT_THROW_MES(ent_type&SERIALIZE_FLAG_ARRAY, "wrong type sequenses"); ------------------ | | 175| 940|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0) | | ------------------ | | | | 174| 5|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());} | | | | ------------------ | | | | | | 100| 5|#define LOG_ERROR(x) MERROR(x) | | | | | | ------------------ | | | | | | | | 75| 5|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | | | ------------------ | | | | | | | | | | 53| 5|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 49| 5|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 43| 5|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | | | 44| 5| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 5] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | | | 47| 5| } while (0) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (175:58): [True: 5, False: 935] | | | Branch (175:105): [Folded - Ignored] | | ------------------ ------------------ 296| 935| return load_storage_array_entry(ent_type); 297| 940| } _ZN4epee13serialization16portable_storage16load_from_binaryENS_4spanIKhEEPKNS1_8limits_tE: 88| 4.45k| { 89| 4.45k| m_root.m_entries.clear(); 90| 4.45k| if(source.size() < sizeof(storage_block_header)) ------------------ | Branch (90:10): [True: 27, False: 4.43k] ------------------ 91| 27| { 92| 27| LOG_ERROR("portable_storage: wrong binary format, packet size = " << source.size() << " less than expected sizeof(storage_block_header)=" << sizeof(storage_block_header)); ------------------ | | 100| 27|#define LOG_ERROR(x) MERROR(x) | | ------------------ | | | | 75| 27|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | ------------------ | | | | | | 53| 27|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | ------------------ | | | | | | | | 49| 27|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | ------------------ | | | | | | | | | | 43| 27|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | 44| 27| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (44:9): [True: 0, False: 27] | | | | | | | | | | ------------------ | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | ------------------ | | | | | | | | | | 46| 0| } \ | | | | | | | | | | 47| 27| } while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 93| 27| return false; 94| 27| } 95| 4.43k| storage_block_header* pbuff = (storage_block_header*)source.data(); 96| 4.43k| if(pbuff->m_signature_a != SWAP32LE(PORTABLE_STORAGE_SIGNATUREA) || ------------------ | | 277| 4.43k|#define SWAP32LE IDENT32 | | ------------------ | | | | 153| 8.86k|#define IDENT32(x) ((uint32_t) (x)) | | ------------------ ------------------ | Branch (96:10): [True: 55, False: 4.37k] ------------------ 97| 4.43k| pbuff->m_signature_b != SWAP32LE(PORTABLE_STORAGE_SIGNATUREB) ------------------ | | 277| 4.37k|#define SWAP32LE IDENT32 | | ------------------ | | | | 153| 4.37k|#define IDENT32(x) ((uint32_t) (x)) | | ------------------ ------------------ | Branch (97:9): [True: 50, False: 4.32k] ------------------ 98| 4.43k| ) 99| 105| { 100| 105| LOG_ERROR("portable_storage: wrong binary format - signature mismatch"); ------------------ | | 100| 105|#define LOG_ERROR(x) MERROR(x) | | ------------------ | | | | 75| 105|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | ------------------ | | | | | | 53| 105|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | ------------------ | | | | | | | | 49| 105|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | ------------------ | | | | | | | | | | 43| 105|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | 44| 105| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (44:9): [True: 0, False: 105] | | | | | | | | | | ------------------ | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | ------------------ | | | | | | | | | | 46| 0| } \ | | | | | | | | | | 47| 105| } while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 101| 105| return false; 102| 105| } 103| 4.32k| if(pbuff->m_ver != PORTABLE_STORAGE_FORMAT_VER) ------------------ | | 39| 4.32k|#define PORTABLE_STORAGE_FORMAT_VER 1 ------------------ | Branch (103:10): [True: 8, False: 4.31k] ------------------ 104| 8| { 105| 8| LOG_ERROR("portable_storage: wrong binary format - unknown format ver = " << pbuff->m_ver); ------------------ | | 100| 8|#define LOG_ERROR(x) MERROR(x) | | ------------------ | | | | 75| 8|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | ------------------ | | | | | | 53| 8|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | ------------------ | | | | | | | | 49| 8|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | ------------------ | | | | | | | | | | 43| 8|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | 44| 8| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (44:9): [True: 0, False: 8] | | | | | | | | | | ------------------ | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | ------------------ | | | | | | | | | | 46| 0| } \ | | | | | | | | | | 47| 8| } while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 106| 8| return false; 107| 8| } 108| 4.31k| TRY_ENTRY(); ------------------ | | 153| 4.31k|#define TRY_ENTRY() try { ------------------ 109| 4.31k| throwable_buffer_reader buf_reader(source.data()+sizeof(storage_block_header), source.size()-sizeof(storage_block_header)); 110| 4.31k| if (limits) ------------------ | Branch (110:11): [True: 0, False: 4.31k] ------------------ 111| 0| buf_reader.set_limits(limits->n_objects, limits->n_fields, limits->n_strings); 112| 4.31k| buf_reader.read(m_root); 113| 4.31k| return true;//TODO: 114| 4.31k| CATCH_ENTRY("portable_storage::load_from_binary", false); ------------------ | | 154| 4.31k|#define CATCH_ENTRY(location, return_val) } \ | | 155| 4.31k| catch(const std::exception& ex) \ | | 156| 3.93k|{ \ | | 157| 3.93k| (void)(ex); \ | | 158| 3.93k| LOG_ERROR("Exception at [" << location << "], what=" << ex.what()); \ | | ------------------ | | | | 100| 3.93k|#define LOG_ERROR(x) MERROR(x) | | | | ------------------ | | | | | | 75| 3.93k|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | ------------------ | | | | | | | | 53| 3.93k|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | ------------------ | | | | | | | | | | 49| 3.93k|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 43| 3.93k|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | 44| 3.93k| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 3.93k] | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | 47| 3.93k| } while (0) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 159| 3.93k| return return_val; \ | | 160| 3.93k|}\ | | 161| 4.31k| catch(...)\ | | 162| 0|{\ | | 163| 0| LOG_ERROR("Exception at [" << location << "], generic exception \"...\"");\ | | ------------------ | | | | 100| 0|#define LOG_ERROR(x) MERROR(x) | | | | ------------------ | | | | | | 75| 0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x) | | | | | | ------------------ | | | | | | | | 53| 0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x) | | | | | | | | ------------------ | | | | | | | | | | 49| 0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x) | | | | | | | | | | ------------------ | | | | | | | | | | | | 43| 0|#define MCLOG_TYPE(level, cat, color, type, x) do { \ | | | | | | | | | | | | 44| 0| if (el::Loggers::allowed(level, cat)) { \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (44:9): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 45| 0| el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 303| 0|# define ELPP_FUNC __PRETTY_FUNCTION__ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 46| 0| } \ | | | | | | | | | | | | 47| 0| } while (0) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (47:12): [Folded - Ignored] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 164| 0| return return_val; \ | | 165| 0|} ------------------ 115| 0| } _ZN2el4base5debug12CrashHandlerC2Eb: 3310| 2|CrashHandler::CrashHandler(bool useDefault) { 3311| 2| if (useDefault) { ------------------ | Branch (3311:7): [True: 0, False: 2] ------------------ 3312| 0| setHandler(defaultCrashHandler); 3313| 0| } 3314| 2|} _ZN2el11LevelHelper12forEachLevelEPjRKNSt3__18functionIFbvEEE: 251| 195k|void LevelHelper::forEachLevel(base::type::EnumType* startIndex, const std::function& fn) { 252| 195k| base::type::EnumType lIndexMax = LevelHelper::kMaxValid; 253| 1.37M| do { 254| 1.37M| if (fn()) { ------------------ | Branch (254:9): [True: 0, False: 1.37M] ------------------ 255| 0| break; 256| 0| } 257| 1.37M| *startIndex = static_cast(*startIndex << 1); 258| 1.37M| } while (*startIndex <= lIndexMax); ------------------ | Branch (258:12): [True: 1.17M, False: 195k] ------------------ 259| 195k|} _ZN2el13ConfigurationC2ENS_5LevelENS_17ConfigurationTypeERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 333| 587k| m_level(level), 334| 587k| m_configurationType(configurationType), 335| 587k| m_value(value) { 336| 587k|} _ZN2el13Configuration9PredicateC2ENS_5LevelENS_17ConfigurationTypeE: 346| 1.63M| m_level(level), 347| 1.63M| m_configurationType(configurationType) { 348| 1.63M|} _ZNK2el13Configuration9PredicateclEPKS0_: 350| 60.2M|bool Configuration::Predicate::operator()(const Configuration* conf) const { 351| 60.2M| return ((conf != nullptr) && (conf->level() == m_level) && (conf->configurationType() == m_configurationType)); ------------------ | Branch (351:11): [True: 60.2M, False: 0] | Branch (351:32): [True: 7.67M, False: 52.6M] | Branch (351:62): [True: 1.04M, False: 6.62M] ------------------ 352| 60.2M|} _ZN2el14ConfigurationsC2Ev: 357| 8.15k| m_configurationFile(std::string()), 358| 8.15k| m_isFromFile(false) { 359| 8.15k|} _ZN2el14Configurations11setFromBaseEPS0_: 393| 4.07k|void Configurations::setFromBase(Configurations* base) { 394| 4.07k| if (base == nullptr || base == this) { ------------------ | Branch (394:7): [True: 0, False: 4.07k] | Branch (394:26): [True: 0, False: 4.07k] ------------------ 395| 0| return; 396| 0| } 397| 4.07k| base::threading::ScopedLock scopedLock(base->lock()); 398| 293k| for (Configuration*& conf : base->list()) { ------------------ | Branch (398:29): [True: 293k, False: 4.07k] ------------------ 399| 293k| set(conf); 400| 293k| } 401| 4.07k|} _ZN2el14Configurations3setENS_5LevelENS_17ConfigurationTypeERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 426| 607k|void Configurations::set(Level level, ConfigurationType configurationType, const std::string& value) { 427| 607k| base::threading::ScopedLock scopedLock(lock()); 428| 607k| unsafeSet(level, configurationType, value); // This is not unsafe anymore as we have locked mutex 429| 607k| if (level == Level::Global) { ------------------ | Branch (429:7): [True: 73.4k, False: 534k] ------------------ 430| 73.4k| unsafeSetGlobally(configurationType, value, false); // Again this is not unsafe either 431| 73.4k| } 432| 607k|} _ZN2el14Configurations3setEPNS_13ConfigurationE: 434| 293k|void Configurations::set(Configuration* conf) { 435| 293k| if (conf == nullptr) { ------------------ | Branch (435:7): [True: 0, False: 293k] ------------------ 436| 0| return; 437| 0| } 438| 293k| set(conf->level(), conf->configurationType(), conf->value()); 439| 293k|} _ZN2el14Configurations12setToDefaultEv: 441| 4.07k|void Configurations::setToDefault(void) { 442| 4.07k| setGlobally(ConfigurationType::Enabled, std::string("true"), true); 443| 4.07k| setGlobally(ConfigurationType::Filename, std::string(base::consts::kDefaultLogFile), true); 444| |#if defined(ELPP_NO_LOG_TO_FILE) 445| | setGlobally(ConfigurationType::ToFile, std::string("false"), true); 446| |#else 447| 4.07k| setGlobally(ConfigurationType::ToFile, std::string("true"), true); 448| 4.07k|#endif // defined(ELPP_NO_LOG_TO_FILE) 449| 4.07k| setGlobally(ConfigurationType::ToStandardOutput, std::string("true"), true); 450| 4.07k| setGlobally(ConfigurationType::SubsecondPrecision, std::string("3"), true); 451| 4.07k| setGlobally(ConfigurationType::PerformanceTracking, std::string("true"), true); 452| 4.07k| setGlobally(ConfigurationType::MaxLogFileSize, std::string("0"), true); 453| 4.07k| setGlobally(ConfigurationType::LogFlushThreshold, std::string("0"), true); 454| | 455| 4.07k| setGlobally(ConfigurationType::Format, std::string("%datetime %level [%logger] %msg"), true); 456| 4.07k| set(Level::Debug, ConfigurationType::Format, 457| 4.07k| std::string("%datetime %level [%logger] [%user@%host] [%func] [%loc] %msg")); 458| | // INFO and WARNING are set to default by Level::Global 459| 4.07k| set(Level::Error, ConfigurationType::Format, std::string("%datetime %level [%logger] %msg")); 460| 4.07k| set(Level::Fatal, ConfigurationType::Format, std::string("%datetime %level [%logger] %msg")); 461| 4.07k| set(Level::Verbose, ConfigurationType::Format, std::string("%datetime %level-%vlevel [%logger] %msg")); 462| 4.07k| set(Level::Trace, ConfigurationType::Format, std::string("%datetime %level [%logger] [%func] [%loc] %msg")); 463| 4.07k|} _ZN2el14Configurations9unsafeSetENS_5LevelENS_17ConfigurationTypeERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 624| 1.63M|void Configurations::unsafeSet(Level level, ConfigurationType configurationType, const std::string& value) { 625| 1.63M| Configuration* conf = RegistryWithPred::get(level, configurationType); 626| 1.63M| if (conf == nullptr) { ------------------ | Branch (626:7): [True: 587k, False: 1.04M] ------------------ 627| 587k| registerNew(new Configuration(level, configurationType, value)); 628| 1.04M| } else { 629| 1.04M| conf->setValue(value); 630| 1.04M| } 631| 1.63M| if (level == Level::Global) { ------------------ | Branch (631:7): [True: 73.4k, False: 1.56M] ------------------ 632| 73.4k| unsafeSetGlobally(configurationType, value, false); 633| 73.4k| } 634| 1.63M|} _ZN2el14Configurations11setGloballyENS_17ConfigurationTypeERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEb: 637| 36.7k| bool includeGlobalLevel) { 638| 36.7k| if (includeGlobalLevel) { ------------------ | Branch (638:7): [True: 36.7k, False: 0] ------------------ 639| 36.7k| set(Level::Global, configurationType, value); 640| 36.7k| } 641| 36.7k| base::type::EnumType lIndex = LevelHelper::kMinValid; 642| 36.7k| LevelHelper::forEachLevel(&lIndex, [&](void) -> bool { 643| 36.7k| set(LevelHelper::castFromInt(lIndex), configurationType, value); 644| 36.7k| return false; // Do not break lambda function yet as we need to set all levels regardless 645| 36.7k| }); 646| 36.7k|} _ZN2el14Configurations17unsafeSetGloballyENS_17ConfigurationTypeERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEb: 649| 146k| bool includeGlobalLevel) { 650| 146k| if (includeGlobalLevel) { ------------------ | Branch (650:7): [True: 0, False: 146k] ------------------ 651| 0| unsafeSet(Level::Global, configurationType, value); 652| 0| } 653| 146k| base::type::EnumType lIndex = LevelHelper::kMinValid; 654| 146k| LevelHelper::forEachLevel(&lIndex, [&](void) -> bool { 655| 146k| unsafeSet(LevelHelper::castFromInt(lIndex), configurationType, value); 656| 146k| return false; // Do not break lambda function yet as we need to set all levels regardless 657| 146k| }); 658| 146k|} _ZN2el6LoggerC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS_14ConfigurationsEPNS1_13unordered_mapIS7_NS1_10shared_ptrINS1_13basic_fstreamIcS4_EEEENS1_4hashIS7_EENS1_8equal_toIS7_EENS5_INS1_4pairIS8_SH_EEEEEE: 712| 4.07k| m_id(id), 713| 4.07k| m_typedConfigurations(nullptr), 714| 4.07k| m_parentApplicationName(std::string()), 715| 4.07k| m_isConfigured(false), 716| 4.07k| m_logStreamsReference(logStreamsReference) { 717| 4.07k| initUnflushedCount(); 718| 4.07k| configure(configurations); 719| 4.07k|} _ZN2el6Logger9configureERKNS_14ConfigurationsE: 745| 4.07k|void Logger::configure(const Configurations& configurations) { 746| 4.07k| m_isConfigured = false; // we set it to false in case if we fail 747| 4.07k| initUnflushedCount(); 748| 4.07k| if (m_typedConfigurations != nullptr) { ------------------ | Branch (748:7): [True: 0, False: 4.07k] ------------------ 749| 0| Configurations* c = const_cast(m_typedConfigurations->configurations()); 750| 0| if (c->hasConfiguration(Level::Global, ConfigurationType::Filename)) { ------------------ | Branch (750:9): [True: 0, False: 0] ------------------ 751| 0| flush(); 752| 0| } 753| 0| } 754| 4.07k| base::threading::ScopedLock scopedLock(lock()); 755| 4.07k| if (m_configurations != configurations) { ------------------ | Branch (755:7): [True: 4.07k, False: 0] ------------------ 756| 4.07k| m_configurations.setFromBase(const_cast(&configurations)); 757| 4.07k| } 758| 4.07k| base::utils::safeDelete(m_typedConfigurations); 759| 4.07k| m_typedConfigurations = new base::TypedConfigurations(&m_configurations, m_logStreamsReference); 760| 4.07k| resolveLoggerFormatSpec(); 761| 4.07k| m_isConfigured = true; 762| 4.07k|} _ZN2el6Logger9isValidIdERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 769| 4.07k|bool Logger::isValidId(const std::string& id) { 770| 32.6k| for (std::string::const_iterator it = id.begin(); it != id.end(); ++it) { ------------------ | Branch (770:53): [True: 28.5k, False: 4.07k] ------------------ 771| 28.5k| if (!base::utils::Str::contains(base::consts::kValidLoggerIdSymbols, *it)) { ------------------ | Branch (771:9): [True: 0, False: 28.5k] ------------------ 772| 0| return false; 773| 0| } 774| 28.5k| } 775| 4.07k| return true; 776| 4.07k|} _ZN2el6Logger18initUnflushedCountEv: 802| 8.15k|void Logger::initUnflushedCount(void) { 803| 8.15k| m_unflushedCount.clear(); 804| 8.15k| base::type::EnumType lIndex = LevelHelper::kMinValid; 805| 8.15k| LevelHelper::forEachLevel(&lIndex, [&](void) -> bool { 806| 8.15k| m_unflushedCount.insert(std::make_pair(LevelHelper::castFromInt(lIndex), 0)); 807| 8.15k| return false; 808| 8.15k| }); 809| 8.15k|} _ZNK2el6Logger23resolveLoggerFormatSpecEv: 811| 4.07k|void Logger::resolveLoggerFormatSpec(void) const { 812| 4.07k| base::type::EnumType lIndex = LevelHelper::kMinValid; 813| 4.07k| LevelHelper::forEachLevel(&lIndex, [&](void) -> bool { 814| 4.07k| base::LogFormat* logFormat = 815| 4.07k| const_cast(&m_typedConfigurations->logFormat(LevelHelper::castFromInt(lIndex))); 816| 4.07k| base::utils::Str::replaceFirstWithEscape(logFormat->m_format, base::consts::kLoggerIdFormatSpecifier, m_id); 817| 4.07k| return false; 818| 4.07k| }); 819| 4.07k|} _ZN2el4base5utils3Str5ltrimERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 988| 228k|std::string& Str::ltrim(std::string& str) { 989| 228k| str.erase(str.begin(), std::find_if(str.begin(), str.end(), [](char c) { 990| 228k| return !std::isspace(c); 991| 228k| } )); 992| 228k| return str; 993| 228k|} _ZN2el4base5utils3Str5rtrimERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 995| 228k|std::string& Str::rtrim(std::string& str) { 996| 228k| str.erase(std::find_if(str.rbegin(), str.rend(), [](char c) { 997| 228k| return !std::isspace(c); 998| 228k| }).base(), str.end()); 999| 228k| return str; 1000| 228k|} _ZN2el4base5utils3Str4trimERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 1002| 228k|std::string& Str::trim(std::string& str) { 1003| 228k| return ltrim(rtrim(str)); 1004| 228k|} _ZN2el4base5utils3Str22replaceFirstWithEscapeERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERKS9_SC_: 1031| 93.8k| const base::type::string_t& replaceWith) { 1032| 93.8k| std::size_t foundAt = base::type::string_t::npos; 1033| 93.8k| while ((foundAt = str.find(replaceWhat, foundAt + 1)) != base::type::string_t::npos) { ------------------ | Branch (1033:10): [True: 65.2k, False: 28.5k] ------------------ 1034| 65.2k| if (foundAt > 0 && str[foundAt - 1] == base::consts::kFormatSpecifierChar) { ------------------ | Branch (1034:9): [True: 65.2k, False: 0] | Branch (1034:24): [True: 0, False: 65.2k] ------------------ 1035| 0| str.erase(foundAt - 1, 1); 1036| 0| ++foundAt; 1037| 65.2k| } else { 1038| 65.2k| str.replace(foundAt, replaceWhat.length(), replaceWith); 1039| 65.2k| return; 1040| 65.2k| } 1041| 65.2k| } 1042| 93.8k|} _ZN2el4base5utils3Str8containsEPKcc: 1083| 28.5k|bool Str::contains(const char* str, char c) { 1084| 281k| for (; *str; ++str) { ------------------ | Branch (1084:10): [True: 281k, False: 0] ------------------ 1085| 281k| if (*str == c) ------------------ | Branch (1085:9): [True: 28.5k, False: 252k] ------------------ 1086| 28.5k| return true; 1087| 281k| } 1088| 0| return false; 1089| 28.5k|} _ZN2el4base5utils2OS22getEnvironmentVariableEPKcS4_S4_: 1198| 69.3k| const char* alternativeBashCommand) { 1199| 69.3k|#if ELPP_OS_UNIX 1200| 69.3k| const char* val = getenv(variableName); 1201| |#elif ELPP_OS_WINDOWS 1202| | const char* val = getWindowsEnvironmentVariable(variableName); 1203| |#endif // ELPP_OS_UNIX 1204| 69.3k| if ((val == nullptr) || ((strcmp(val, "") == 0))) { ------------------ | Branch (1204:7): [True: 36.7k, False: 32.6k] | Branch (1204:27): [True: 0, False: 32.6k] ------------------ 1205| |#if ELPP_OS_UNIX && defined(ELPP_FORCE_ENV_VAR_FROM_BASH) 1206| | // Try harder on unix-based systems 1207| | std::string valBash = base::utils::OS::getBashOutput(alternativeBashCommand); 1208| | if (valBash.empty()) { 1209| | return std::string(defaultVal); 1210| | } else { 1211| | return valBash; 1212| | } 1213| |#elif ELPP_OS_WINDOWS || ELPP_OS_UNIX 1214| 36.7k| ELPP_UNUSED(alternativeBashCommand); ------------------ | | 240| 36.7k|#define ELPP_UNUSED(x) (void)x ------------------ 1215| 36.7k| return std::string(defaultVal); 1216| 36.7k|#endif // ELPP_OS_UNIX && defined(ELPP_FORCE_ENV_VAR_FROM_BASH) 1217| 36.7k| } 1218| 32.6k| return std::string(val); 1219| 69.3k|} _ZN2el4base5utils2OS11currentUserEv: 1221| 32.6k|std::string OS::currentUser(void) { 1222| 32.6k|#if ELPP_OS_UNIX && !ELPP_OS_ANDROID 1223| 32.6k| return getEnvironmentVariable("USER", base::consts::kUnknownUser, "whoami"); 1224| |#elif ELPP_OS_WINDOWS 1225| | return getEnvironmentVariable("USERNAME", base::consts::kUnknownUser); 1226| |#elif ELPP_OS_ANDROID 1227| | ELPP_UNUSED(base::consts::kUnknownUser); 1228| | return std::string("android"); 1229| |#else 1230| | return std::string(); 1231| |#endif // ELPP_OS_UNIX && !ELPP_OS_ANDROID 1232| 32.6k|} _ZN2el4base5utils2OS11currentHostEv: 1234| 32.6k|std::string OS::currentHost(void) { 1235| 32.6k|#if ELPP_OS_UNIX && !ELPP_OS_ANDROID 1236| 32.6k| return getEnvironmentVariable("HOSTNAME", base::consts::kUnknownHost, "hostname"); 1237| |#elif ELPP_OS_WINDOWS 1238| | return getEnvironmentVariable("COMPUTERNAME", base::consts::kUnknownHost); 1239| |#elif ELPP_OS_ANDROID 1240| | ELPP_UNUSED(base::consts::kUnknownHost); 1241| | return getDeviceName(); 1242| |#else 1243| | return std::string(); 1244| |#endif // ELPP_OS_UNIX && !ELPP_OS_ANDROID 1245| 32.6k|} _ZN2el4base5utils2OS17termSupportsColorEv: 1247| 4.07k|bool OS::termSupportsColor(void) { 1248| 4.07k| std::string term = getEnvironmentVariable("TERM", ""); 1249| 4.07k| return term == "xterm" || term == "xterm-color" || term == "xterm-256color" ------------------ | Branch (1249:10): [True: 0, False: 4.07k] | Branch (1249:29): [True: 0, False: 4.07k] | Branch (1249:54): [True: 0, False: 4.07k] ------------------ 1250| 4.07k| || term == "screen" || term == "linux" || term == "cygwin" ------------------ | Branch (1250:13): [True: 0, False: 4.07k] | Branch (1250:33): [True: 0, False: 4.07k] | Branch (1250:52): [True: 0, False: 4.07k] ------------------ 1251| 4.07k| || term == "screen-256color" || term == "screen.xterm-256color"; ------------------ | Branch (1251:13): [True: 0, False: 4.07k] | Branch (1251:42): [True: 0, False: 4.07k] ------------------ 1252| 4.07k|} _ZN2el4base5utils15CommandLineArgs7setArgsEiPPc: 1423| 4.07k|void CommandLineArgs::setArgs(int argc, char** argv) { 1424| 4.07k| m_params.clear(); 1425| 4.07k| m_paramsWithValue.clear(); 1426| 4.07k| if (argc == 0 || argv == nullptr) { ------------------ | Branch (1426:7): [True: 4.07k, False: 0] | Branch (1426:20): [True: 0, False: 0] ------------------ 1427| 4.07k| return; 1428| 4.07k| } 1429| 0| m_argc = argc; 1430| 0| m_argv = argv; 1431| 0| for (int i = 1; i < m_argc; ++i) { ------------------ | Branch (1431:19): [True: 0, False: 0] ------------------ 1432| 0| const char* v = (strstr(m_argv[i], "=")); 1433| 0| if (v != nullptr && strlen(v) > 0) { ------------------ | Branch (1433:9): [True: 0, False: 0] | Branch (1433:25): [True: 0, False: 0] ------------------ 1434| 0| std::string key = std::string(m_argv[i]); 1435| 0| key = key.substr(0, key.find_first_of('=')); 1436| 0| if (hasParamWithValue(key.c_str())) { ------------------ | Branch (1436:11): [True: 0, False: 0] ------------------ 1437| 0| ELPP_INTERNAL_INFO(1, "Skipping [" << key << "] arg since it already has value [" 1438| 0| << getParamValue(key.c_str()) << "]"); 1439| 0| } else { 1440| 0| m_paramsWithValue.insert(std::make_pair(key, std::string(v + 1))); 1441| 0| } 1442| 0| } 1443| 0| if (v == nullptr) { ------------------ | Branch (1443:9): [True: 0, False: 0] ------------------ 1444| 0| if (hasParam(m_argv[i])) { ------------------ | Branch (1444:11): [True: 0, False: 0] ------------------ 1445| 0| ELPP_INTERNAL_INFO(1, "Skipping [" << m_argv[i] << "] arg since it already exists"); 1446| 0| } else { 1447| 0| m_params.push_back(std::string(m_argv[i])); 1448| 0| } 1449| 0| } 1450| 0| } 1451| 0|} _ZN2el4base18SubsecondPrecision4initEi: 1510| 32.6k|void SubsecondPrecision::init(int width) { 1511| 32.6k| if (width < 1 || width > 6) { ------------------ | Branch (1511:7): [True: 0, False: 32.6k] | Branch (1511:20): [True: 0, False: 32.6k] ------------------ 1512| 0| width = base::consts::kDefaultSubsecondPrecision; 1513| 0| } 1514| 32.6k| m_width = width; 1515| 32.6k| switch (m_width) { 1516| 32.6k| case 3: ------------------ | Branch (1516:3): [True: 32.6k, False: 0] ------------------ 1517| 32.6k| m_offset = 1000; 1518| 32.6k| break; 1519| 0| case 4: ------------------ | Branch (1519:3): [True: 0, False: 32.6k] ------------------ 1520| 0| m_offset = 100; 1521| 0| break; 1522| 0| case 5: ------------------ | Branch (1522:3): [True: 0, False: 32.6k] ------------------ 1523| 0| m_offset = 10; 1524| 0| break; 1525| 0| case 6: ------------------ | Branch (1525:3): [True: 0, False: 32.6k] ------------------ 1526| 0| m_offset = 1; 1527| 0| break; 1528| 0| default: ------------------ | Branch (1528:3): [True: 0, False: 32.6k] ------------------ 1529| 0| m_offset = 1000; 1530| 0| break; 1531| 32.6k| } 1532| 32.6k|} _ZN2el4base9LogFormatC2ENS_5LevelERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 1547| 32.6k| : m_level(level), m_userFormat(format), m_currentUser(base::utils::OS::currentUser()), 1548| 32.6k| m_currentHost(base::utils::OS::currentHost()) { 1549| 32.6k| parseFromFormat(m_userFormat); 1550| 32.6k|} _ZN2el4base9LogFormatC2ERKS1_: 1553| 32.6k| m_level(logFormat.m_level), 1554| 32.6k| m_userFormat(logFormat.m_userFormat), 1555| 32.6k| m_format(logFormat.m_format), 1556| 32.6k| m_dateTimeFormat(logFormat.m_dateTimeFormat), 1557| 32.6k| m_flags(logFormat.m_flags), 1558| 32.6k| m_currentUser(logFormat.m_currentUser), 1559| 32.6k| m_currentHost(logFormat.m_currentHost) { 1560| 32.6k|} _ZN2el4base9LogFormatC2EOS1_: 1562| 32.6k|LogFormat::LogFormat(LogFormat&& logFormat) { 1563| 32.6k| m_level = std::move(logFormat.m_level); 1564| 32.6k| m_userFormat = std::move(logFormat.m_userFormat); 1565| 32.6k| m_format = std::move(logFormat.m_format); 1566| 32.6k| m_dateTimeFormat = std::move(logFormat.m_dateTimeFormat); 1567| 32.6k| m_flags = std::move(logFormat.m_flags); 1568| 32.6k| m_currentUser = std::move(logFormat.m_currentUser); 1569| 32.6k| m_currentHost = std::move(logFormat.m_currentHost); 1570| 32.6k|} _ZN2el4base9LogFormateqERKS1_: 1584| 28.5k|bool LogFormat::operator==(const LogFormat& other) { 1585| 28.5k| return m_level == other.m_level && m_userFormat == other.m_userFormat && m_format == other.m_format && ------------------ | Branch (1585:10): [True: 0, False: 28.5k] | Branch (1585:38): [True: 0, False: 0] | Branch (1585:76): [True: 0, False: 0] ------------------ 1586| 28.5k| m_dateTimeFormat == other.m_dateTimeFormat && m_flags == other.m_flags; ------------------ | Branch (1586:10): [True: 0, False: 0] | Branch (1586:56): [True: 0, False: 0] ------------------ 1587| 28.5k|} _ZN2el4base9LogFormat15parseFromFormatERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 1591| 32.6k|void LogFormat::parseFromFormat(const base::type::string_t& userFormat) { 1592| | // We make copy because we will be changing the format 1593| | // i.e, removing user provided date format from original format 1594| | // and then storing it. 1595| 32.6k| base::type::string_t formatCopy = userFormat; 1596| 32.6k| m_flags = 0x0; 1597| 32.6k| auto conditionalAddFlag = [&](const base::type::char_t* specifier, base::FormatFlags flag) { 1598| 32.6k| std::size_t foundAt = base::type::string_t::npos; 1599| 32.6k| while ((foundAt = formatCopy.find(specifier, foundAt + 1)) != base::type::string_t::npos) { 1600| 32.6k| if (foundAt > 0 && formatCopy[foundAt - 1] == base::consts::kFormatSpecifierChar) { 1601| 32.6k| if (hasFlag(flag)) { 1602| | // If we already have flag we remove the escape chars so that '%%' is turned to '%' 1603| | // even after specifier resolution - this is because we only replaceFirst specifier 1604| 32.6k| formatCopy.erase(foundAt - 1, 1); 1605| 32.6k| ++foundAt; 1606| 32.6k| } 1607| 32.6k| } else { 1608| 32.6k| if (!hasFlag(flag)) addFlag(flag); 1609| 32.6k| } 1610| 32.6k| } 1611| 32.6k| }; 1612| 32.6k| conditionalAddFlag(base::consts::kAppNameFormatSpecifier, base::FormatFlags::AppName); 1613| 32.6k| conditionalAddFlag(base::consts::kSeverityLevelFormatSpecifier, base::FormatFlags::Level); 1614| 32.6k| conditionalAddFlag(base::consts::kSeverityLevelShortFormatSpecifier, base::FormatFlags::LevelShort); 1615| 32.6k| conditionalAddFlag(base::consts::kLoggerIdFormatSpecifier, base::FormatFlags::LoggerId); 1616| 32.6k| conditionalAddFlag(base::consts::kThreadIdFormatSpecifier, base::FormatFlags::ThreadId); 1617| 32.6k| conditionalAddFlag(base::consts::kLogFileFormatSpecifier, base::FormatFlags::File); 1618| 32.6k| conditionalAddFlag(base::consts::kLogFileBaseFormatSpecifier, base::FormatFlags::FileBase); 1619| 32.6k| conditionalAddFlag(base::consts::kLogLineFormatSpecifier, base::FormatFlags::Line); 1620| 32.6k| conditionalAddFlag(base::consts::kLogLocationFormatSpecifier, base::FormatFlags::Location); 1621| 32.6k| conditionalAddFlag(base::consts::kLogFunctionFormatSpecifier, base::FormatFlags::Function); 1622| 32.6k| conditionalAddFlag(base::consts::kCurrentUserFormatSpecifier, base::FormatFlags::User); 1623| 32.6k| conditionalAddFlag(base::consts::kCurrentHostFormatSpecifier, base::FormatFlags::Host); 1624| 32.6k| conditionalAddFlag(base::consts::kMessageFormatSpecifier, base::FormatFlags::LogMessage); 1625| 32.6k| conditionalAddFlag(base::consts::kVerboseLevelFormatSpecifier, base::FormatFlags::VerboseLevel); 1626| | // For date/time we need to extract user's date format first 1627| 32.6k| std::size_t dateIndex = std::string::npos; 1628| 32.6k| if ((dateIndex = formatCopy.find(base::consts::kDateTimeFormatSpecifier)) != std::string::npos) { ------------------ | Branch (1628:7): [True: 32.6k, False: 0] ------------------ 1629| 32.6k| while (dateIndex > 0 && formatCopy[dateIndex - 1] == base::consts::kFormatSpecifierChar) { ------------------ | Branch (1629:12): [True: 0, False: 32.6k] | Branch (1629:29): [True: 0, False: 0] ------------------ 1630| 0| dateIndex = formatCopy.find(base::consts::kDateTimeFormatSpecifier, dateIndex + 1); 1631| 0| } 1632| 32.6k| if (dateIndex != std::string::npos) { ------------------ | Branch (1632:9): [True: 32.6k, False: 0] ------------------ 1633| 32.6k| addFlag(base::FormatFlags::DateTime); 1634| 32.6k| updateDateFormat(dateIndex, formatCopy); 1635| 32.6k| } 1636| 32.6k| } 1637| 32.6k| m_format = formatCopy; 1638| 32.6k| updateFormatSpec(); 1639| 32.6k|} _ZN2el4base9LogFormat16updateDateFormatEmRNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 1641| 32.6k|void LogFormat::updateDateFormat(std::size_t index, base::type::string_t& currFormat) { 1642| 32.6k| if (hasFlag(base::FormatFlags::DateTime)) { ------------------ | Branch (1642:7): [True: 32.6k, False: 0] ------------------ 1643| 32.6k| index += ELPP_STRLEN(base::consts::kDateTimeFormatSpecifier); ------------------ | | 540| 32.6k|# define ELPP_STRLEN strlen ------------------ 1644| 32.6k| } 1645| 32.6k| const base::type::char_t* ptr = currFormat.c_str() + index; 1646| 32.6k| if ((currFormat.size() > index) && (ptr[0] == '{')) { ------------------ | Branch (1646:7): [True: 32.6k, False: 0] | Branch (1646:38): [True: 0, False: 32.6k] ------------------ 1647| | // User has provided format for date/time 1648| 0| ++ptr; 1649| 0| int count = 1; // Start by 1 in order to remove starting brace 1650| 0| std::stringstream ss; 1651| 0| for (; *ptr; ++ptr, ++count) { ------------------ | Branch (1651:12): [True: 0, False: 0] ------------------ 1652| 0| if (*ptr == '}') { ------------------ | Branch (1652:11): [True: 0, False: 0] ------------------ 1653| 0| ++count; // In order to remove ending brace 1654| 0| break; 1655| 0| } 1656| 0| ss << static_cast(*ptr); 1657| 0| } 1658| 0| currFormat.erase(index, count); 1659| 0| m_dateTimeFormat = ss.str(); 1660| 32.6k| } else { 1661| | // No format provided, use default 1662| 32.6k| if (hasFlag(base::FormatFlags::DateTime)) { ------------------ | Branch (1662:9): [True: 32.6k, False: 0] ------------------ 1663| 32.6k| m_dateTimeFormat = std::string(base::consts::kDefaultDateTimeFormat); 1664| 32.6k| } 1665| 32.6k| } 1666| 32.6k|} _ZN2el4base9LogFormat16updateFormatSpecEv: 1668| 32.6k|void LogFormat::updateFormatSpec(void) { 1669| | // Do not use switch over strongly typed enums because Intel C++ compilers dont support them yet. 1670| 32.6k| if (m_level == Level::Debug) { ------------------ | Branch (1670:7): [True: 4.07k, False: 28.5k] ------------------ 1671| 4.07k| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier, 1672| 4.07k| base::consts::kDebugLevelLogValue); 1673| 4.07k| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier, 1674| 4.07k| base::consts::kDebugLevelShortLogValue); 1675| 28.5k| } else if (m_level == Level::Info) { ------------------ | Branch (1675:14): [True: 4.07k, False: 24.4k] ------------------ 1676| 4.07k| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier, 1677| 4.07k| base::consts::kInfoLevelLogValue); 1678| 4.07k| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier, 1679| 4.07k| base::consts::kInfoLevelShortLogValue); 1680| 24.4k| } else if (m_level == Level::Warning) { ------------------ | Branch (1680:14): [True: 4.07k, False: 20.3k] ------------------ 1681| 4.07k| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier, 1682| 4.07k| base::consts::kWarningLevelLogValue); 1683| 4.07k| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier, 1684| 4.07k| base::consts::kWarningLevelShortLogValue); 1685| 20.3k| } else if (m_level == Level::Error) { ------------------ | Branch (1685:14): [True: 4.07k, False: 16.3k] ------------------ 1686| 4.07k| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier, 1687| 4.07k| base::consts::kErrorLevelLogValue); 1688| 4.07k| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier, 1689| 4.07k| base::consts::kErrorLevelShortLogValue); 1690| 16.3k| } else if (m_level == Level::Fatal) { ------------------ | Branch (1690:14): [True: 4.07k, False: 12.2k] ------------------ 1691| 4.07k| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier, 1692| 4.07k| base::consts::kFatalLevelLogValue); 1693| 4.07k| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier, 1694| 4.07k| base::consts::kFatalLevelShortLogValue); 1695| 12.2k| } else if (m_level == Level::Verbose) { ------------------ | Branch (1695:14): [True: 4.07k, False: 8.15k] ------------------ 1696| 4.07k| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier, 1697| 4.07k| base::consts::kVerboseLevelLogValue); 1698| 4.07k| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier, 1699| 4.07k| base::consts::kVerboseLevelShortLogValue); 1700| 8.15k| } else if (m_level == Level::Trace) { ------------------ | Branch (1700:14): [True: 4.07k, False: 4.07k] ------------------ 1701| 4.07k| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier, 1702| 4.07k| base::consts::kTraceLevelLogValue); 1703| 4.07k| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier, 1704| 4.07k| base::consts::kTraceLevelShortLogValue); 1705| 4.07k| } 1706| 32.6k| if (hasFlag(base::FormatFlags::User)) { ------------------ | Branch (1706:7): [True: 4.07k, False: 28.5k] ------------------ 1707| 4.07k| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kCurrentUserFormatSpecifier, 1708| 4.07k| m_currentUser); 1709| 4.07k| } 1710| 32.6k| if (hasFlag(base::FormatFlags::Host)) { ------------------ | Branch (1710:7): [True: 4.07k, False: 28.5k] ------------------ 1711| 4.07k| base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kCurrentHostFormatSpecifier, 1712| 4.07k| m_currentHost); 1713| 4.07k| } 1714| | // Ignore Level::Global and Level::Unknown 1715| 32.6k|} _ZN2el4base19TypedConfigurationsC2EPNS_14ConfigurationsEPNSt3__113unordered_mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS4_10shared_ptrINS4_13basic_fstreamIcS8_EEEENS4_4hashISB_EENS4_8equal_toISB_EENS9_INS4_4pairIKSB_SF_EEEEEE: 1720| 4.07k| base::LogStreamsReferenceMap* logStreamsReference) { 1721| 4.07k| m_configurations = configurations; 1722| 4.07k| m_logStreamsReference = logStreamsReference; 1723| 4.07k| build(m_configurations); 1724| 4.07k|} _ZN2el4base19TypedConfigurations9logFormatENS_5LevelE: 1748| 28.5k|const base::LogFormat& TypedConfigurations::logFormat(Level level) { 1749| 28.5k| return getConfigByRef(level, &m_logFormatMap, "logFormat"); 1750| 28.5k|} _ZN2el4base19TypedConfigurations5buildEPNS_14ConfigurationsE: 1776| 4.07k|void TypedConfigurations::build(Configurations* configurations) { 1777| 4.07k| base::threading::ScopedLock scopedLock(lock()); 1778| 4.07k| auto getBool = [] (std::string boolStr) -> bool { // Pass by value for trimming 1779| 4.07k| base::utils::Str::trim(boolStr); 1780| 4.07k| return (boolStr == "TRUE" || boolStr == "true" || boolStr == "1"); 1781| 4.07k| }; 1782| 4.07k| setValue(Level::Global, base::FileStreamPtr(NULL), &m_fileStreamMap); 1783| 4.07k| std::vector withFileSizeLimit; 1784| 297k| for (Configurations::const_iterator it = configurations->begin(); it != configurations->end(); ++it) { ------------------ | Branch (1784:69): [True: 293k, False: 4.07k] ------------------ 1785| 293k| Configuration* conf = *it; 1786| | // We cannot use switch on strong enums because Intel C++ dont support them yet 1787| 293k| if (conf->configurationType() == ConfigurationType::Enabled) { ------------------ | Branch (1787:9): [True: 32.6k, False: 261k] ------------------ 1788| 32.6k| setValue(conf->level(), getBool(conf->value()), &m_enabledMap); 1789| 261k| } else if (conf->configurationType() == ConfigurationType::ToFile) { ------------------ | Branch (1789:16): [True: 32.6k, False: 228k] ------------------ 1790| 32.6k| setValue(conf->level(), getBool(conf->value()), &m_toFileMap); 1791| 228k| } else if (conf->configurationType() == ConfigurationType::ToStandardOutput) { ------------------ | Branch (1791:16): [True: 32.6k, False: 195k] ------------------ 1792| 32.6k| setValue(conf->level(), getBool(conf->value()), &m_toStandardOutputMap); 1793| 195k| } else if (conf->configurationType() == ConfigurationType::Filename) { ------------------ | Branch (1793:16): [True: 32.6k, False: 163k] ------------------ 1794| | // We do not yet configure filename but we will configure in another 1795| | // loop. This is because if file cannot be created, we will force ToFile 1796| | // to be false. Because configuring logger is not necessarily performance 1797| | // sensative operation, we can live with another loop; (by the way this loop 1798| | // is not very heavy either) 1799| 163k| } else if (conf->configurationType() == ConfigurationType::Format) { ------------------ | Branch (1799:16): [True: 32.6k, False: 130k] ------------------ 1800| 32.6k| setValue(conf->level(), base::LogFormat(conf->level(), 1801| 32.6k| base::type::string_t(conf->value().begin(), conf->value().end())), &m_logFormatMap); 1802| 130k| } else if (conf->configurationType() == ConfigurationType::SubsecondPrecision) { ------------------ | Branch (1802:16): [True: 32.6k, False: 97.8k] ------------------ 1803| 32.6k| setValue(Level::Global, 1804| 32.6k| base::SubsecondPrecision(static_cast(getULong(conf->value()))), &m_subsecondPrecisionMap); 1805| 97.8k| } else if (conf->configurationType() == ConfigurationType::PerformanceTracking) { ------------------ | Branch (1805:16): [True: 32.6k, False: 65.2k] ------------------ 1806| 32.6k| setValue(Level::Global, getBool(conf->value()), &m_performanceTrackingMap); 1807| 65.2k| } else if (conf->configurationType() == ConfigurationType::MaxLogFileSize) { ------------------ | Branch (1807:16): [True: 32.6k, False: 32.6k] ------------------ 1808| 32.6k| auto v = getULong(conf->value()); 1809| 32.6k| setValue(conf->level(), static_cast(v), &m_maxLogFileSizeMap); 1810| 32.6k| if (v != 0) { ------------------ | Branch (1810:11): [True: 0, False: 32.6k] ------------------ 1811| 0| withFileSizeLimit.push_back(conf); 1812| 0| } 1813| 32.6k| } else if (conf->configurationType() == ConfigurationType::LogFlushThreshold) { ------------------ | Branch (1813:16): [True: 32.6k, False: 0] ------------------ 1814| 32.6k| setValue(conf->level(), static_cast(getULong(conf->value())), &m_logFlushThresholdMap); 1815| 32.6k| } 1816| 293k| } 1817| | // As mentioned earlier, we will now set filename configuration in separate loop to deal with non-existent files 1818| 297k| for (Configurations::const_iterator it = configurations->begin(); it != configurations->end(); ++it) { ------------------ | Branch (1818:69): [True: 293k, False: 4.07k] ------------------ 1819| 293k| Configuration* conf = *it; 1820| 293k| if (conf->configurationType() == ConfigurationType::Filename) { ------------------ | Branch (1820:9): [True: 32.6k, False: 261k] ------------------ 1821| 32.6k| insertFile(conf->level(), conf->value()); 1822| 32.6k| } 1823| 293k| } 1824| 4.07k| for (std::vector::iterator conf = withFileSizeLimit.begin(); 1825| 4.07k| conf != withFileSizeLimit.end(); ++conf) { ------------------ | Branch (1825:8): [True: 0, False: 4.07k] ------------------ 1826| | // This is not unsafe as mutex is locked in currect scope 1827| 0| unsafeValidateFileRolling((*conf)->level(), base::defaultPreRollOutCallback); 1828| 0| } 1829| 4.07k|} _ZN2el4base19TypedConfigurations8getULongENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 1831| 97.8k|unsigned long TypedConfigurations::getULong(std::string confVal) { 1832| 97.8k| bool valid = true; 1833| 97.8k| base::utils::Str::trim(confVal); 1834| 97.8k| valid = !confVal.empty() && std::find_if(confVal.begin(), confVal.end(), ------------------ | Branch (1834:11): [True: 97.8k, False: 0] | Branch (1834:31): [True: 97.8k, False: 0] ------------------ 1835| 97.8k| [](char c) { 1836| 97.8k| return !base::utils::Str::isDigit(c); 1837| 97.8k| }) == confVal.end(); 1838| 97.8k| if (!valid) { ------------------ | Branch (1838:7): [True: 0, False: 97.8k] ------------------ 1839| 0| valid = false; 1840| 0| ELPP_ASSERT(valid, "Configuration value not a valid integer [" << confVal << "]"); ------------------ | | 178| 0|# define ELPP_ASSERT(expr, msg) if (!(expr)) { \ | | ------------------ | | | Branch (178:40): [True: 0, False: 0] | | ------------------ | | 179| 0|std::stringstream internalInfoStream; internalInfoStream << msg; \ | | ------------------ | | | | 160| 0|# define ELPP_INTERNAL_DEBUGGING_OUT_ERROR std::cerr | | ------------------ | | 180| 0|ELPP_INTERNAL_DEBUGGING_OUT_ERROR\ | | 181| 0|<< "ASSERTION FAILURE FROM EASYLOGGING++ (LINE: " \ | | 182| 0|<< __LINE__ << ") [" #expr << "] WITH MESSAGE \"" << ELPP_INTERNAL_DEBUGGING_MSG(internalInfoStream.str()) << "\"" \ | | ------------------ | | | | 166| 0|# define ELPP_INTERNAL_DEBUGGING_MSG(msg) msg | | ------------------ | | 183| 0|<< ELPP_INTERNAL_DEBUGGING_ENDL; } | | ------------------ | | | | 163| 0|# define ELPP_INTERNAL_DEBUGGING_ENDL std::endl | | ------------------ ------------------ 1841| 0| return 0; 1842| 0| } 1843| 97.8k| return atol(confVal.c_str()); 1844| 97.8k|} _ZN2el4base19TypedConfigurations10insertFileENS_5LevelERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 1885| 32.6k|void TypedConfigurations::insertFile(Level level, const std::string& fullFilename) { 1886| 32.6k| if (fullFilename.empty()) ------------------ | Branch (1886:7): [True: 32.6k, False: 0] ------------------ 1887| 32.6k| return; 1888| 0| std::string resolvedFilename = resolveFilename(fullFilename); 1889| 0| if (resolvedFilename.empty()) { ------------------ | Branch (1889:7): [True: 0, False: 0] ------------------ 1890| 0| std::cerr << "Could not load empty file for logging, please re-check your configurations for level [" 1891| 0| << LevelHelper::convertToString(level) << "]"; 1892| 0| } 1893| 0| std::string filePath = base::utils::File::extractPathFromFilename(resolvedFilename, base::consts::kFilePathSeperator); 1894| 0| if (filePath.size() < resolvedFilename.size()) { ------------------ | Branch (1894:7): [True: 0, False: 0] ------------------ 1895| 0| base::utils::File::createPath(filePath); 1896| 0| } 1897| 0| auto create = [&](Level level) { 1898| 0| base::LogStreamsReferenceMap::iterator filestreamIter = m_logStreamsReference->find(resolvedFilename); 1899| 0| base::type::fstream_t* fs = nullptr; 1900| 0| if (filestreamIter == m_logStreamsReference->end()) { 1901| | // We need a completely new stream, nothing to share with 1902| 0| fs = base::utils::File::newFileStream(resolvedFilename); 1903| 0| m_filenameMap.insert(std::make_pair(level, resolvedFilename)); 1904| 0| m_fileStreamMap.insert(std::make_pair(level, base::FileStreamPtr(fs))); 1905| 0| m_logStreamsReference->insert(std::make_pair(resolvedFilename, base::FileStreamPtr(m_fileStreamMap.at(level)))); 1906| 0| } else { 1907| | // Woops! we have an existing one, share it! 1908| 0| m_filenameMap.insert(std::make_pair(level, filestreamIter->first)); 1909| 0| m_fileStreamMap.insert(std::make_pair(level, base::FileStreamPtr(filestreamIter->second))); 1910| 0| fs = filestreamIter->second.get(); 1911| 0| } 1912| 0| if (fs == nullptr) { 1913| | // We display bad file error from newFileStream() 1914| 0| ELPP_INTERNAL_ERROR("Setting [TO_FILE] of [" 1915| 0| << LevelHelper::convertToString(level) << "] to FALSE", false); 1916| 0| setValue(level, false, &m_toFileMap); 1917| 0| } 1918| 0| }; 1919| | // If we dont have file conf for any level, create it for Level::Global first 1920| | // otherwise create for specified level 1921| 0| create(m_filenameMap.empty() && m_fileStreamMap.empty() ? Level::Global : level); ------------------ | Branch (1921:10): [True: 0, False: 0] | Branch (1921:35): [True: 0, False: 0] ------------------ 1922| 0|} _ZN2el4base17RegisteredLoggersC2ERKNSt3__110shared_ptrINS_10LogBuilderEEE: 1991| 4.07k| m_defaultLogBuilder(defaultLogBuilder) { 1992| 4.07k| m_defaultConfigurations.setToDefault(); 1993| 4.07k|} _ZN2el4base17RegisteredLoggers3getERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEb: 1995| 8.15k|Logger* RegisteredLoggers::get(const std::string& id, bool forceCreation) { 1996| 8.15k| base::threading::ScopedLock scopedLock(lock()); 1997| 8.15k| Logger* logger_ = base::utils::Registry::get(id); 1998| 8.15k| if (logger_ == nullptr && forceCreation) { ------------------ | Branch (1998:7): [True: 4.07k, False: 4.07k] | Branch (1998:29): [True: 4.07k, False: 0] ------------------ 1999| 4.07k| bool validId = Logger::isValidId(id); 2000| 4.07k| if (!validId) { ------------------ | Branch (2000:9): [True: 0, False: 4.07k] ------------------ 2001| 0| ELPP_ASSERT(validId, "Invalid logger ID [" << id << "]. Not registering this logger."); ------------------ | | 178| 0|# define ELPP_ASSERT(expr, msg) if (!(expr)) { \ | | ------------------ | | | Branch (178:40): [True: 0, False: 0] | | ------------------ | | 179| 0|std::stringstream internalInfoStream; internalInfoStream << msg; \ | | ------------------ | | | | 160| 0|# define ELPP_INTERNAL_DEBUGGING_OUT_ERROR std::cerr | | ------------------ | | 180| 0|ELPP_INTERNAL_DEBUGGING_OUT_ERROR\ | | 181| 0|<< "ASSERTION FAILURE FROM EASYLOGGING++ (LINE: " \ | | 182| 0|<< __LINE__ << ") [" #expr << "] WITH MESSAGE \"" << ELPP_INTERNAL_DEBUGGING_MSG(internalInfoStream.str()) << "\"" \ | | ------------------ | | | | 166| 0|# define ELPP_INTERNAL_DEBUGGING_MSG(msg) msg | | ------------------ | | 183| 0|<< ELPP_INTERNAL_DEBUGGING_ENDL; } | | ------------------ | | | | 163| 0|# define ELPP_INTERNAL_DEBUGGING_ENDL std::endl | | ------------------ ------------------ 2002| 0| return nullptr; 2003| 0| } 2004| 4.07k| logger_ = new Logger(id, m_defaultConfigurations, &m_logStreamsReference); 2005| 4.07k| logger_->m_logBuilder = m_defaultLogBuilder; 2006| 4.07k| registerNew(id, logger_); 2007| 4.07k| LoggerRegistrationCallback* callback = nullptr; 2008| 4.07k| for (const std::pair& h 2009| 4.07k| : m_loggerRegistrationCallbacks) { ------------------ | Branch (2009:10): [True: 0, False: 4.07k] ------------------ 2010| 0| callback = h.second.get(); 2011| 0| if (callback != nullptr && callback->enabled()) { ------------------ | Branch (2011:11): [True: 0, False: 0] | Branch (2011:34): [True: 0, False: 0] ------------------ 2012| 0| callback->handle(logger_); 2013| 0| } 2014| 0| } 2015| 4.07k| } 2016| 8.15k| return logger_; 2017| 8.15k|} _ZN2el4base17RegisteredLoggers14unsafeFlushAllEv: 2032| 4.07k|void RegisteredLoggers::unsafeFlushAll(void) { 2033| 4.07k| ELPP_INTERNAL_INFO(1, "Flushing all log files"); 2034| 4.07k| for (base::LogStreamsReferenceMap::iterator it = m_logStreamsReference.begin(); 2035| 4.07k| it != m_logStreamsReference.end(); ++it) { ------------------ | Branch (2035:8): [True: 0, False: 4.07k] ------------------ 2036| 0| if (it->second.get() == nullptr) continue; ------------------ | Branch (2036:9): [True: 0, False: 0] ------------------ 2037| 0| it->second->flush(); 2038| 0| } 2039| 4.07k|} _ZN2el4base9VRegistryC2EtPj: 2043| 4.07k|VRegistry::VRegistry(base::type::VerboseLevel level, base::type::EnumType* pFlags) : m_level(level), m_pFlags(pFlags) { 2044| 4.07k|} _ZN2el4base9VRegistry16priority_allowedEiRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 2222| 8.01k|bool VRegistry::priority_allowed(const int pri, const std::string &category) { 2223| 8.01k| base::threading::ScopedLock scopedLock(lock()); 2224| 8.01k| const std::map::const_iterator it = m_cached_allowed_categories.find(category); 2225| 8.01k| if (it != m_cached_allowed_categories.end()) ------------------ | Branch (2225:7): [True: 0, False: 8.01k] ------------------ 2226| 0| return pri <= it->second; 2227| 8.01k| if (m_categories.empty()) { ------------------ | Branch (2227:7): [True: 8.01k, False: 0] ------------------ 2228| 8.01k| return false; 2229| 8.01k| } else { 2230| 0| std::vector>::const_reverse_iterator it = m_categories.rbegin(); 2231| 0| for (; it != m_categories.rend(); ++it) { ------------------ | Branch (2231:12): [True: 0, False: 0] ------------------ 2232| 0| if (base::utils::Str::wildCardMatch(category.c_str(), it->first.c_str())) { ------------------ | Branch (2232:11): [True: 0, False: 0] ------------------ 2233| 0| const int p = priority(it->second); 2234| 0| m_cached_allowed_categories.insert(std::make_pair(category, p)); 2235| 0| return pri <= p; 2236| 0| } 2237| 0| } 2238| 0| m_cached_allowed_categories.insert(std::make_pair(category, -1)); 2239| 0| return false; 2240| 0| } 2241| 8.01k|} _ZN2el4base7Storage7getELPPEv: 2283| 8.01k|{ 2284| 8.01k| if (!el::base::elStorage) ------------------ | Branch (2284:7): [True: 4.07k, False: 3.94k] ------------------ 2285| 4.07k| el::base::elStorage = new el::base::Storage(el::LogBuilderPtr(new el::base::DefaultLogBuilder())); 2286| 8.01k| return el::base::elStorage; 2287| 8.01k|} _ZN2el4base7StorageC2ERKNSt3__110shared_ptrINS_10LogBuilderEEE: 2294| 4.07k| m_registeredHitCounters(new base::RegisteredHitCounters()), 2295| 4.07k| m_registeredLoggers(new base::RegisteredLoggers(defaultLogBuilder)), 2296| 4.07k| m_flags(ELPP_DEFAULT_LOGGING_FLAGS), ------------------ | | 2279| 4.07k|# define ELPP_DEFAULT_LOGGING_FLAGS 0x0 ------------------ 2297| 4.07k| m_vRegistry(new base::VRegistry(0, &m_flags)), 2298| | 2299| |#if ELPP_ASYNC_LOGGING 2300| | m_asyncLogQueue(new base::AsyncLogQueue()), 2301| | m_asyncDispatchWorker(asyncDispatchWorker), 2302| |#endif // ELPP_ASYNC_LOGGING 2303| | 2304| 4.07k| m_preRollOutCallback(base::defaultPreRollOutCallback) { 2305| | // Register default logger 2306| 4.07k| m_registeredLoggers->get(std::string(base::consts::kDefaultLoggerId)); 2307| | // We register default logger anyway (worse case it's not going to register) just in case 2308| 4.07k| m_registeredLoggers->get("default"); 2309| | 2310| |#if defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING) 2311| | // Register performance logger and reconfigure format 2312| | Logger* performanceLogger = m_registeredLoggers->get(std::string(base::consts::kPerformanceLoggerId)); 2313| | m_registeredLoggers->get("performance"); 2314| | performanceLogger->configurations()->setGlobally(ConfigurationType::Format, std::string("%datetime %level %msg")); 2315| | performanceLogger->reconfigure(); 2316| |#endif // defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING) 2317| | 2318| |#if defined(ELPP_SYSLOG) 2319| | // Register syslog logger and reconfigure format 2320| | Logger* sysLogLogger = m_registeredLoggers->get(std::string(base::consts::kSysLogLoggerId)); 2321| | sysLogLogger->configurations()->setGlobally(ConfigurationType::Format, std::string("%level: %msg")); 2322| | sysLogLogger->reconfigure(); 2323| |#endif // defined(ELPP_SYSLOG) 2324| 4.07k| addFlag(LoggingFlag::AllowVerboseIfModuleNotSpecified); 2325| 4.07k| addFlag(LoggingFlag::CreateLoggerAutomatically); 2326| |#if ELPP_ASYNC_LOGGING 2327| | installLogDispatchCallback(std::string("AsyncLogDispatchCallback")); 2328| |#else 2329| 4.07k| installLogDispatchCallback(std::string("DefaultLogDispatchCallback")); 2330| 4.07k|#endif // ELPP_ASYNC_LOGGING 2331| |#if defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING) 2332| | installPerformanceTrackingCallback 2333| | (std::string("DefaultPerformanceTrackingCallback")); 2334| |#endif // defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING) 2335| 4.07k| ELPP_INTERNAL_INFO(1, "Easylogging++ has been initialized"); 2336| |#if ELPP_ASYNC_LOGGING 2337| | m_asyncDispatchWorker->start(); 2338| |#endif // ELPP_ASYNC_LOGGING 2339| 4.07k|} _ZN2el4base7StorageD2Ev: 2341| 4.07k|Storage::~Storage(void) { 2342| 4.07k| ELPP_INTERNAL_INFO(4, "Destroying storage"); 2343| |#if ELPP_ASYNC_LOGGING 2344| | ELPP_INTERNAL_INFO(5, "Replacing log dispatch callback to synchronous"); 2345| | uninstallLogDispatchCallback(std::string("AsyncLogDispatchCallback")); 2346| | installLogDispatchCallback(std::string("DefaultLogDispatchCallback")); 2347| | ELPP_INTERNAL_INFO(5, "Destroying asyncDispatchWorker"); 2348| | base::utils::safeDelete(m_asyncDispatchWorker); 2349| | ELPP_INTERNAL_INFO(5, "Destroying asyncLogQueue"); 2350| | base::utils::safeDelete(m_asyncLogQueue); 2351| |#endif // ELPP_ASYNC_LOGGING 2352| 4.07k| ELPP_INTERNAL_INFO(5, "Destroying registeredHitCounters"); 2353| 4.07k| base::utils::safeDelete(m_registeredHitCounters); 2354| 4.07k| ELPP_INTERNAL_INFO(5, "Destroying registeredLoggers"); 2355| 4.07k| base::utils::safeDelete(m_registeredLoggers); 2356| 4.07k| ELPP_INTERNAL_INFO(5, "Destroying vRegistry"); 2357| 4.07k| base::utils::safeDelete(m_vRegistry); 2358| 4.07k|} _ZN2el7Loggers7allowedENS_5LevelEPKc: 3361| 8.01k|{ 3362| 8.01k| const int pri = base::priority(level); 3363| 8.01k| if (pri > base::s_lowest_priority) ------------------ | Branch (3363:7): [True: 0, False: 8.01k] ------------------ 3364| 0| return false; 3365| 8.01k| return ELPP->vRegistry()->priority_allowed(pri, std::string{cat}); ------------------ | | 2792| 8.01k|#define ELPP el::base::Storage::getELPP() ------------------ 3366| 8.01k|} easylogging++.cc:_ZZN2el4base9LogFormat15parseFromFormatERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEENK3$_0clEPKcNS0_11FormatFlagsE: 1597| 456k| auto conditionalAddFlag = [&](const base::type::char_t* specifier, base::FormatFlags flag) { 1598| 456k| std::size_t foundAt = base::type::string_t::npos; 1599| 583k| while ((foundAt = formatCopy.find(specifier, foundAt + 1)) != base::type::string_t::npos) { ------------------ | Branch (1599:12): [True: 126k, False: 456k] ------------------ 1600| 126k| if (foundAt > 0 && formatCopy[foundAt - 1] == base::consts::kFormatSpecifierChar) { ------------------ | Branch (1600:11): [True: 126k, False: 0] | Branch (1600:26): [True: 0, False: 126k] ------------------ 1601| 0| if (hasFlag(flag)) { ------------------ | Branch (1601:13): [True: 0, False: 0] ------------------ 1602| | // If we already have flag we remove the escape chars so that '%%' is turned to '%' 1603| | // even after specifier resolution - this is because we only replaceFirst specifier 1604| 0| formatCopy.erase(foundAt - 1, 1); 1605| 0| ++foundAt; 1606| 0| } 1607| 126k| } else { 1608| 126k| if (!hasFlag(flag)) addFlag(flag); ------------------ | Branch (1608:13): [True: 126k, False: 0] ------------------ 1609| 126k| } 1610| 126k| } 1611| 456k| }; easylogging++.cc:_ZZN2el4base19TypedConfigurations5buildEPNS_14ConfigurationsEENK3$_0clENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE: 1778| 130k| auto getBool = [] (std::string boolStr) -> bool { // Pass by value for trimming 1779| 130k| base::utils::Str::trim(boolStr); 1780| 130k| return (boolStr == "TRUE" || boolStr == "true" || boolStr == "1"); ------------------ | Branch (1780:13): [True: 0, False: 130k] | Branch (1780:34): [True: 130k, False: 0] | Branch (1780:55): [True: 0, False: 0] ------------------ 1781| 130k| }; easylogging++.cc:_ZN2el4baseL8priorityENS_5LevelE: 2128| 8.01k|static int priority(Level level) { 2129| 8.01k| if (level == Level::Fatal) return 0; ------------------ | Branch (2129:7): [True: 0, False: 8.01k] ------------------ 2130| 8.01k| if (level == Level::Error) return 1; ------------------ | Branch (2130:7): [True: 8.01k, False: 0] ------------------ 2131| 0| if (level == Level::Warning) return 2; ------------------ | Branch (2131:7): [True: 0, False: 0] ------------------ 2132| 0| if (level == Level::Info) return 3; ------------------ | Branch (2132:7): [True: 0, False: 0] ------------------ 2133| 0| if (level == Level::Debug) return 4; ------------------ | Branch (2133:7): [True: 0, False: 0] ------------------ 2134| 0| if (level == Level::Verbose) return 5; ------------------ | Branch (2134:7): [True: 0, False: 0] ------------------ 2135| 0| if (level == Level::Trace) return 6; ------------------ | Branch (2135:7): [True: 0, False: 0] ------------------ 2136| 0| return 7; 2137| 0|} _ZN2el4base10EnsureELPPC2Ev: 2288| 2|static struct EnsureELPP { EnsureELPP() { el::base::Storage::getELPP(); } } ensureELPP; easylogging++.cc:_ZZN2el14Configurations11setGloballyENS_17ConfigurationTypeERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEbENK3$_0clEv: 642| 256k| LevelHelper::forEachLevel(&lIndex, [&](void) -> bool { 643| 256k| set(LevelHelper::castFromInt(lIndex), configurationType, value); 644| 256k| return false; // Do not break lambda function yet as we need to set all levels regardless 645| 256k| }); easylogging++.cc:_ZZN2el14Configurations17unsafeSetGloballyENS_17ConfigurationTypeERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEbENK3$_0clEv: 654| 1.02M| LevelHelper::forEachLevel(&lIndex, [&](void) -> bool { 655| 1.02M| unsafeSet(LevelHelper::castFromInt(lIndex), configurationType, value); 656| 1.02M| return false; // Do not break lambda function yet as we need to set all levels regardless 657| 1.02M| }); easylogging++.cc:_ZZN2el6Logger18initUnflushedCountEvENK3$_0clEv: 805| 57.1k| LevelHelper::forEachLevel(&lIndex, [&](void) -> bool { 806| 57.1k| m_unflushedCount.insert(std::make_pair(LevelHelper::castFromInt(lIndex), 0)); 807| 57.1k| return false; 808| 57.1k| }); easylogging++.cc:_ZZNK2el6Logger23resolveLoggerFormatSpecEvENK3$_0clEv: 813| 28.5k| LevelHelper::forEachLevel(&lIndex, [&](void) -> bool { 814| 28.5k| base::LogFormat* logFormat = 815| 28.5k| const_cast(&m_typedConfigurations->logFormat(LevelHelper::castFromInt(lIndex))); 816| 28.5k| base::utils::Str::replaceFirstWithEscape(logFormat->m_format, base::consts::kLoggerIdFormatSpecifier, m_id); 817| 28.5k| return false; 818| 28.5k| }); easylogging++.cc:_ZZN2el4base5utils3Str5ltrimERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEENK3$_0clEc: 989| 228k| str.erase(str.begin(), std::find_if(str.begin(), str.end(), [](char c) { 990| 228k| return !std::isspace(c); 991| 228k| } )); easylogging++.cc:_ZZN2el4base5utils3Str5rtrimERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEENK3$_0clEc: 996| 228k| str.erase(std::find_if(str.rbegin(), str.rend(), [](char c) { 997| 228k| return !std::isspace(c); 998| 228k| }).base(), str.end()); easylogging++.cc:_ZZN2el4base19TypedConfigurations8getULongENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEENK3$_0clEc: 1835| 97.8k| [](char c) { 1836| 97.8k| return !base::utils::Str::isDigit(c); 1837| 97.8k| }) == confVal.end(); _ZN2el4base6NoCopyC2Ev: 571| 12.2k| NoCopy(void) {} _ZNKSt3__14hashIN2el5LevelEEclERKS2_: 624| 407k| std::size_t operator()(const el::Level& l) const { 625| 407k| return hash {}(static_cast(l)); 626| 407k| } _ZN2el11LevelHelper11castFromIntEj: 642| 1.37M| static Level castFromInt(base::type::EnumType l) { 643| 1.37M| return static_cast(l); 644| 1.37M| } _ZN2el4base18SubsecondPrecisionC2Ei: 870| 32.6k| explicit SubsecondPrecision(int width) { 871| 32.6k| init(width); 872| 32.6k| } _ZN2el4base18SubsecondPrecisioneqERKS1_: 873| 28.5k| bool operator==(const SubsecondPrecision& ssPrec) { 874| 28.5k| return m_width == ssPrec.m_width && m_offset == ssPrec.m_offset; ------------------ | Branch (874:12): [True: 28.5k, False: 0] | Branch (874:41): [True: 28.5k, False: 0] ------------------ 875| 28.5k| } _ZN2el4base9threading10ThreadSafe4lockEv: 1037| 664k| virtual inline base::threading::Mutex& lock(void) ELPP_FINAL { return m_mutex; } _ZN2el4base9threading10ThreadSafeC2Ev: 1039| 36.7k| ThreadSafe(void) {} _ZN2el4base9threading10ThreadSafeD2Ev: 1040| 36.7k| virtual ~ThreadSafe(void) {} _ZN2el4base5utils3Str7isDigitEc: 1107| 97.8k| static inline bool isDigit(char c) { 1108| 97.8k| return c >= '0' && c <= '9'; ------------------ | Branch (1108:12): [True: 97.8k, False: 0] | Branch (1108:24): [True: 97.8k, False: 0] ------------------ 1109| 97.8k| } _ZN2el4base5utils15CommandLineArgsC2Ev: 1251| 4.07k| CommandLineArgs(void) { 1252| 4.07k| setArgs(0, static_cast(nullptr)); 1253| 4.07k| } _ZN2el4base5utils15CommandLineArgsD2Ev: 1260| 4.07k| virtual ~CommandLineArgs(void) {} _ZN2el8LoggableD2Ev: 1603| 689k| virtual ~Loggable(void) {} _ZN2el4base9LogFormatD2Ev: 1620| 97.8k| virtual ~LogFormat(void) {} _ZNK2el4base9LogFormat7hasFlagENS0_11FormatFlagsE: 1647| 256k| inline bool hasFlag(base::FormatFlags flag) const { 1648| 256k| return base::utils::hasFlag(flag, m_flags); 1649| 256k| } _ZN2el4base9LogFormat7addFlagENS0_11FormatFlagsE: 1664| 159k| inline void addFlag(base::FormatFlags flag) { 1665| 159k| base::utils::addFlag(flag, &m_flags); 1666| 159k| } _ZN2el13ConfigurationD2Ev: 1716| 587k| virtual ~Configuration(void) { 1717| 587k| } _ZNK2el13Configuration5levelEv: 1723| 60.8M| inline Level level(void) const { 1724| 60.8M| return m_level; 1725| 60.8M| } _ZNK2el13Configuration17configurationTypeEv: 1728| 9.72M| inline ConfigurationType configurationType(void) const { 1729| 9.72M| return m_configurationType; 1730| 9.72M| } _ZNK2el13Configuration5valueEv: 1733| 620k| inline const std::string& value(void) const { 1734| 620k| return m_value; 1735| 620k| } _ZN2el13Configuration8setValueERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 1740| 1.04M| inline void setValue(const std::string& value) { 1741| 1.04M| m_value = value; 1742| 1.04M| } _ZN2el14ConfigurationsD2Ev: 1781| 8.15k| virtual ~Configurations(void) { 1782| 8.15k| } _ZN2el4base19TypedConfigurationsD2Ev: 1950| 4.07k| virtual ~TypedConfigurations(void) { 1951| 4.07k| } _ZN2el10LogBuilderC2Ev: 2237| 4.07k| LogBuilder() : m_termSupportsColor(base::utils::OS::termSupportsColor()) {} _ZN2el10LogBuilderD2Ev: 2238| 4.07k| virtual ~LogBuilder(void) { 2239| 4.07k| ELPP_INTERNAL_INFO(3, "Destroying log builder...") 2240| 4.07k| } _ZN2el6LoggerD2Ev: 2259| 4.07k| virtual ~Logger(void) { 2260| 4.07k| base::utils::safeDelete(m_typedConfigurations); 2261| 4.07k| } _ZN2el4base17RegisteredLoggersD2Ev: 2390| 4.07k| virtual ~RegisteredLoggers(void) { 2391| 4.07k| unsafeFlushAll(); 2392| 4.07k| } _ZNK2el4base7Storage9vRegistryEv: 2645| 8.01k| inline base::VRegistry* vRegistry(void) const { 2646| 8.01k| return m_vRegistry; 2647| 8.01k| } _ZN2el4base7Storage7addFlagENS_11LoggingFlagE: 2659| 8.15k| inline void addFlag(LoggingFlag flag) { 2660| 8.15k| base::utils::addFlag(flag, &m_flags); 2661| 8.15k| } _ZN2el4base5utils16RegistryWithPredINS_13ConfigurationENS3_9PredicateEE3getINS_5LevelENS_17ConfigurationTypeEEEPS3_RKT_T0_: 1554| 1.63M| T_Ptr* get(const T& arg1, const T2 arg2) { 1555| 1.63M| iterator iter = std::find_if(this->list().begin(), this->list().end(), Pred(arg1, arg2)); 1556| 1.63M| if (iter != this->list().end() && *iter != nullptr) { ------------------ | Branch (1556:9): [True: 1.04M, False: 587k] | Branch (1556:9): [True: 1.04M, False: 587k] | Branch (1556:39): [True: 1.04M, False: 0] ------------------ 1557| 1.04M| return *iter; 1558| 1.04M| } 1559| 587k| return nullptr; 1560| 1.63M| } _ZN2el4base5utils16RegistryWithPredINS_13ConfigurationENS3_9PredicateEE13unregisterAllEv: 1523| 8.15k| virtual void unregisterAll(void) ELPP_FINAL { 1524| 8.15k| if (!this->empty()) { ------------------ | Branch (1524:9): [True: 8.15k, False: 0] ------------------ 1525| 587k| for (auto&& curr : this->list()) { ------------------ | Branch (1525:24): [True: 587k, False: 8.15k] ------------------ 1526| 587k| base::utils::safeDelete(curr); 1527| 587k| } 1528| 8.15k| this->list().clear(); 1529| 8.15k| } 1530| 8.15k| } _ZN2el4base5utils8RegistryINS_6LoggerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEE10unregisterERKSA_: 1455| 4.07k| void unregister(const T_Key& uniqKey) { 1456| 4.07k| T_Ptr* existing = get(uniqKey); 1457| 4.07k| if (existing != nullptr) { ------------------ | Branch (1457:9): [True: 0, False: 4.07k] ------------------ 1458| 0| this->list().erase(uniqKey); 1459| 0| base::utils::safeDelete(existing); 1460| 0| } 1461| 4.07k| } _ZN2el4base5utils8RegistryINS_6LoggerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEE3getERKSA_: 1464| 12.2k| T_Ptr* get(const T_Key& uniqKey) { 1465| 12.2k| iterator it = this->list().find(uniqKey); 1466| 12.2k| return it == this->list().end() ------------------ | Branch (1466:12): [True: 8.15k, False: 4.07k] ------------------ 1467| 12.2k| ? nullptr 1468| 12.2k| : it->second; 1469| 12.2k| } _ZN2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEE5beginEv: 1348| 8.15k| virtual inline iterator begin(void) ELPP_FINAL { 1349| 8.15k| return m_list.begin(); 1350| 8.15k| } _ZN2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEE3endEv: 1353| 595k| virtual inline iterator end(void) ELPP_FINAL { 1354| 595k| return m_list.end(); 1355| 595k| } _ZNK2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEE5emptyEv: 1369| 8.15k| virtual inline bool empty(void) const ELPP_FINAL { 1370| 8.15k| return m_list.empty(); 1371| 8.15k| } _ZNK2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEE4sizeEv: 1374| 8.15k| virtual inline std::size_t size(void) const ELPP_FINAL { 1375| 8.15k| return m_list.size(); 1376| 8.15k| } _ZN2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEE4listEv: 1379| 5.51M| virtual inline Container& list(void) ELPP_FINAL { 1380| 5.51M| return m_list; 1381| 5.51M| } _ZN2el4base5utils16RegistryWithPredINS_13ConfigurationENS3_9PredicateEE11registerNewEPS3_: 1547| 587k| virtual inline void registerNew(T_Ptr* ptr) ELPP_FINAL { 1548| 587k| this->list().push_back(ptr); 1549| 587k| } _ZNK2el4base5utils16AbstractRegistryINS_6LoggerENSt3__113unordered_mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPS3_NS4_4hashISB_EENS4_8equal_toISB_EENS9_INS4_4pairIKSB_SC_EEEEEEE5emptyEv: 1369| 4.07k| virtual inline bool empty(void) const ELPP_FINAL { 1370| 4.07k| return m_list.empty(); 1371| 4.07k| } _ZN2el4base5utils16AbstractRegistryINS_6LoggerENSt3__113unordered_mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPS3_NS4_4hashISB_EENS4_8equal_toISB_EENS9_INS4_4pairIKSB_SC_EEEEEEE4listEv: 1379| 36.7k| virtual inline Container& list(void) ELPP_FINAL { 1380| 36.7k| return m_list; 1381| 36.7k| } _ZN2el4base5utils8RegistryINS_6LoggerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEE13unregisterAllEv: 1439| 4.07k| virtual void unregisterAll(void) ELPP_FINAL { 1440| 4.07k| if (!this->empty()) { ------------------ | Branch (1440:9): [True: 4.07k, False: 0] ------------------ 1441| 4.07k| for (auto&& curr : this->list()) { ------------------ | Branch (1441:24): [True: 4.07k, False: 4.07k] ------------------ 1442| 4.07k| base::utils::safeDelete(curr.second); 1443| 4.07k| } 1444| 4.07k| this->list().clear(); 1445| 4.07k| } 1446| 4.07k| } _ZN2el4base5utils8RegistryINS_6LoggerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEE11registerNewERKSA_PS3_: 1449| 4.07k| virtual void registerNew(const T_Key& uniqKey, T_Ptr* ptr) ELPP_FINAL { 1450| 4.07k| unregister(uniqKey); 1451| 4.07k| this->list().insert(std::make_pair(uniqKey, ptr)); 1452| 4.07k| } easylogging++.cc:_ZN2el4base5utilsL7addFlagINS0_11FormatFlagsEEEvT_Pj: 912| 159k|static inline void addFlag(Enum e, base::type::EnumType* flag) { 913| 159k| *flag = base::utils::bitwise::Or(e, *flag); 914| 159k|} easylogging++.cc:_ZN2el4base5utils7bitwiseL2OrINS0_11FormatFlagsEEEjT_j: 907| 159k|static inline base::type::EnumType Or(Enum e, base::type::EnumType flag) { 908| 159k| return static_cast(flag) | static_cast(e); 909| 159k|} easylogging++.cc:_ZN2el4base5utilsL7hasFlagINS0_11FormatFlagsEEEbT_j: 920| 256k|static inline bool hasFlag(Enum e, base::type::EnumType flag) { 921| 256k| return base::utils::bitwise::And(e, flag) > 0x0; 922| 256k|} easylogging++.cc:_ZN2el4base5utils7bitwiseL3AndINS0_11FormatFlagsEEEjT_j: 899| 256k|static inline base::type::EnumType And(Enum e, base::type::EnumType flag) { 900| 256k| return static_cast(flag) & static_cast(e); 901| 256k|} easylogging++.cc:_ZN2el4base5utilsL10safeDeleteINS_6LoggerEEENSt3__19enable_ifIXsr3std10is_pointerIPT_EE5valueEvE4typeERS7_: 889| 4.07k|safeDelete(T*& pointer) { 890| 4.07k| if (pointer == nullptr) ------------------ | Branch (890:7): [True: 0, False: 4.07k] ------------------ 891| 0| return; 892| 4.07k| delete pointer; 893| 4.07k| pointer = nullptr; 894| 4.07k|} _ZN2el4base5utils16RegistryWithPredINS0_10HitCounterENS3_9PredicateEEC2Ev: 1489| 4.07k| RegistryWithPred(void) { 1490| 4.07k| } _ZN2el4base5utils16AbstractRegistryINS0_10HitCounterENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEEC2Ev: 1299| 4.07k| AbstractRegistry(void) {} _ZN2el4base5utils16AbstractRegistryINS0_10HitCounterENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEED2Ev: 1344| 4.07k| virtual ~AbstractRegistry(void) { 1345| 4.07k| } _ZN2el4base5utils16RegistryWithPredINS0_10HitCounterENS3_9PredicateEED2Ev: 1492| 4.07k| virtual ~RegistryWithPred(void) { 1493| 4.07k| unregisterAll(); 1494| 4.07k| } _ZNK2el4base5utils16AbstractRegistryINS0_10HitCounterENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEE5emptyEv: 1369| 4.07k| virtual inline bool empty(void) const ELPP_FINAL { 1370| 4.07k| return m_list.empty(); 1371| 4.07k| } _ZN2el4base5utils16RegistryWithPredINS0_10HitCounterENS3_9PredicateEE13unregisterAllEv: 1523| 4.07k| virtual void unregisterAll(void) ELPP_FINAL { 1524| 4.07k| if (!this->empty()) { ------------------ | Branch (1524:9): [True: 0, False: 4.07k] ------------------ 1525| 0| for (auto&& curr : this->list()) { ------------------ | Branch (1525:24): [True: 0, False: 0] ------------------ 1526| 0| base::utils::safeDelete(curr); 1527| 0| } 1528| 0| this->list().clear(); 1529| 0| } 1530| 4.07k| } easylogging++.cc:_ZN2el4base5utilsL7addFlagINS_11LoggingFlagEEEvT_Pj: 912| 8.15k|static inline void addFlag(Enum e, base::type::EnumType* flag) { 913| 8.15k| *flag = base::utils::bitwise::Or(e, *flag); 914| 8.15k|} easylogging++.cc:_ZN2el4base5utils7bitwiseL2OrINS_11LoggingFlagEEEjT_j: 907| 8.15k|static inline base::type::EnumType Or(Enum e, base::type::EnumType flag) { 908| 8.15k| return static_cast(flag) | static_cast(e); 909| 8.15k|} _ZN2el4base5utils16RegistryWithPredINS_13ConfigurationENS3_9PredicateEED2Ev: 1492| 8.15k| virtual ~RegistryWithPred(void) { 1493| 8.15k| unregisterAll(); 1494| 8.15k| } _ZN2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEED2Ev: 1344| 8.15k| virtual ~AbstractRegistry(void) { 1345| 8.15k| } easylogging++.cc:_ZN2el4base5utilsL10safeDeleteINS0_19TypedConfigurationsEEENSt3__19enable_ifIXsr3std10is_pointerIPT_EE5valueEvE4typeERS7_: 889| 8.15k|safeDelete(T*& pointer) { 890| 8.15k| if (pointer == nullptr) ------------------ | Branch (890:7): [True: 4.07k, False: 4.07k] ------------------ 891| 4.07k| return; 892| 4.07k| delete pointer; 893| 4.07k| pointer = nullptr; 894| 4.07k|} _ZN2el4base5utils8RegistryINS_6LoggerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEED2Ev: 1434| 4.07k| virtual ~Registry(void) { 1435| 4.07k| unregisterAll(); 1436| 4.07k| } _ZN2el4base5utils16AbstractRegistryINS_6LoggerENSt3__113unordered_mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPS3_NS4_4hashISB_EENS4_8equal_toISB_EENS9_INS4_4pairIKSB_SC_EEEEEEED2Ev: 1344| 4.07k| virtual ~AbstractRegistry(void) { 1345| 4.07k| } _ZN2el4base5utils16RegistryWithPredINS_13ConfigurationENS3_9PredicateEEC2Ev: 1489| 8.15k| RegistryWithPred(void) { 1490| 8.15k| } _ZN2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEEC2Ev: 1299| 8.15k| AbstractRegistry(void) {} _ZN2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEEneERKSA_: 1322| 4.07k| bool operator!=(const AbstractRegistry& other) { 1323| 4.07k| if (size() != other.size()) { ------------------ | Branch (1323:9): [True: 4.07k, False: 0] ------------------ 1324| 4.07k| return true; 1325| 4.07k| } 1326| 0| for (std::size_t i = 0; i < m_list.size(); ++i) { ------------------ | Branch (1326:29): [True: 0, False: 0] ------------------ 1327| 0| if (m_list.at(i) != other.m_list.at(i)) { ------------------ | Branch (1327:11): [True: 0, False: 0] ------------------ 1328| 0| return true; 1329| 0| } 1330| 0| } 1331| 0| return false; 1332| 0| } _ZN2el4base19TypedConfigurations14getConfigByRefINS0_9LogFormatEEERT_NS_5LevelEPNSt3__113unordered_mapIS6_S4_NS7_4hashIS6_EENS7_8equal_toIS6_EENS7_9allocatorINS7_4pairIKS6_S4_EEEEEEPKc: 1996| 28.5k| inline Conf_T& getConfigByRef(Level level, std::unordered_map* confMap, const char* confName) { 1997| 28.5k| base::threading::ScopedLock scopedLock(lock()); 1998| 28.5k| return unsafeGetConfigByRef(level, confMap, confName); // This is not unsafe anymore - mutex locked in scope 1999| 28.5k| } _ZN2el4base19TypedConfigurations20unsafeGetConfigByRefINS0_9LogFormatEEERT_NS_5LevelEPNSt3__113unordered_mapIS6_S4_NS7_4hashIS6_EENS7_8equal_toIS6_EENS7_9allocatorINS7_4pairIKS6_S4_EEEEEEPKc: 2019| 28.5k| Conf_T& unsafeGetConfigByRef(Level level, std::unordered_map* confMap, const char* confName) { 2020| 28.5k| ELPP_UNUSED(confName); ------------------ | | 240| 28.5k|#define ELPP_UNUSED(x) (void)x ------------------ 2021| 28.5k| typename std::unordered_map::iterator it = confMap->find(level); 2022| 28.5k| if (it == confMap->end()) { ------------------ | Branch (2022:9): [True: 0, False: 28.5k] ------------------ 2023| 0| try { 2024| 0| return confMap->at(Level::Global); 2025| 0| } catch (...) { 2026| 0| ELPP_INTERNAL_ERROR("Unable to get configuration [" << confName << "] for level [" 2027| 0| << LevelHelper::convertToString(level) << "]" 2028| 0| << std::endl << "Please ensure you have properly configured logger.", false); 2029| 0| throw; // The exception has to be rethrown, to abort a branch leading to UB. 2030| 0| } 2031| 0| } 2032| 28.5k| return it->second; 2033| 28.5k| } _ZN2el4base19TypedConfigurations8setValueINSt3__110shared_ptrINS3_13basic_fstreamIcNS3_11char_traitsIcEEEEEEEEvNS_5LevelERKT_PNS3_13unordered_mapISA_SB_NS3_4hashISA_EENS3_8equal_toISA_EENS3_9allocatorINS3_4pairIKSA_SB_EEEEEEb: 2037| 4.07k| bool includeGlobalLevel = true) { 2038| | // If map is empty and we are allowed to add into generic level (Level::Global), do it! 2039| 4.07k| if (confMap->empty() && includeGlobalLevel) { ------------------ | Branch (2039:9): [True: 4.07k, False: 0] | Branch (2039:29): [True: 4.07k, False: 0] ------------------ 2040| 4.07k| confMap->insert(std::make_pair(Level::Global, value)); 2041| 4.07k| return; 2042| 4.07k| } 2043| | // If same value exist in generic level already, dont add it to explicit level 2044| 0| typename std::unordered_map::iterator it = confMap->find(Level::Global); 2045| 0| if (it != confMap->end() && it->second == value) { ------------------ | Branch (2045:9): [True: 0, False: 0] | Branch (2045:9): [True: 0, False: 0] | Branch (2045:33): [True: 0, False: 0] ------------------ 2046| 0| return; 2047| 0| } 2048| | // Now make sure we dont double up values if we really need to add it to explicit level 2049| 0| it = confMap->find(level); 2050| 0| if (it == confMap->end()) { ------------------ | Branch (2050:9): [True: 0, False: 0] ------------------ 2051| | // Value not found for level, add new 2052| 0| confMap->insert(std::make_pair(level, value)); 2053| 0| } else { 2054| | // Value found, just update value 2055| 0| confMap->at(level) = value; 2056| 0| } 2057| 0| } _ZN2el4base19TypedConfigurations8setValueIbEEvNS_5LevelERKT_PNSt3__113unordered_mapIS3_S4_NS7_4hashIS3_EENS7_8equal_toIS3_EENS7_9allocatorINS7_4pairIKS3_S4_EEEEEEb: 2037| 130k| bool includeGlobalLevel = true) { 2038| | // If map is empty and we are allowed to add into generic level (Level::Global), do it! 2039| 130k| if (confMap->empty() && includeGlobalLevel) { ------------------ | Branch (2039:9): [True: 16.3k, False: 114k] | Branch (2039:29): [True: 16.3k, False: 0] ------------------ 2040| 16.3k| confMap->insert(std::make_pair(Level::Global, value)); 2041| 16.3k| return; 2042| 16.3k| } 2043| | // If same value exist in generic level already, dont add it to explicit level 2044| 114k| typename std::unordered_map::iterator it = confMap->find(Level::Global); 2045| 114k| if (it != confMap->end() && it->second == value) { ------------------ | Branch (2045:9): [True: 114k, False: 0] | Branch (2045:9): [True: 114k, False: 0] | Branch (2045:33): [True: 114k, False: 0] ------------------ 2046| 114k| return; 2047| 114k| } 2048| | // Now make sure we dont double up values if we really need to add it to explicit level 2049| 0| it = confMap->find(level); 2050| 0| if (it == confMap->end()) { ------------------ | Branch (2050:9): [True: 0, False: 0] ------------------ 2051| | // Value not found for level, add new 2052| 0| confMap->insert(std::make_pair(level, value)); 2053| 0| } else { 2054| | // Value found, just update value 2055| 0| confMap->at(level) = value; 2056| 0| } 2057| 0| } _ZN2el4base19TypedConfigurations8setValueINS0_9LogFormatEEEvNS_5LevelERKT_PNSt3__113unordered_mapIS4_S5_NS8_4hashIS4_EENS8_8equal_toIS4_EENS8_9allocatorINS8_4pairIKS4_S5_EEEEEEb: 2037| 32.6k| bool includeGlobalLevel = true) { 2038| | // If map is empty and we are allowed to add into generic level (Level::Global), do it! 2039| 32.6k| if (confMap->empty() && includeGlobalLevel) { ------------------ | Branch (2039:9): [True: 4.07k, False: 28.5k] | Branch (2039:29): [True: 4.07k, False: 0] ------------------ 2040| 4.07k| confMap->insert(std::make_pair(Level::Global, value)); 2041| 4.07k| return; 2042| 4.07k| } 2043| | // If same value exist in generic level already, dont add it to explicit level 2044| 28.5k| typename std::unordered_map::iterator it = confMap->find(Level::Global); 2045| 28.5k| if (it != confMap->end() && it->second == value) { ------------------ | Branch (2045:9): [True: 28.5k, False: 0] | Branch (2045:9): [True: 0, False: 28.5k] | Branch (2045:33): [True: 0, False: 28.5k] ------------------ 2046| 0| return; 2047| 0| } 2048| | // Now make sure we dont double up values if we really need to add it to explicit level 2049| 28.5k| it = confMap->find(level); 2050| 28.5k| if (it == confMap->end()) { ------------------ | Branch (2050:9): [True: 28.5k, False: 0] ------------------ 2051| | // Value not found for level, add new 2052| 28.5k| confMap->insert(std::make_pair(level, value)); 2053| 28.5k| } else { 2054| | // Value found, just update value 2055| 0| confMap->at(level) = value; 2056| 0| } 2057| 28.5k| } _ZN2el4base19TypedConfigurations8setValueINS0_18SubsecondPrecisionEEEvNS_5LevelERKT_PNSt3__113unordered_mapIS4_S5_NS8_4hashIS4_EENS8_8equal_toIS4_EENS8_9allocatorINS8_4pairIKS4_S5_EEEEEEb: 2037| 32.6k| bool includeGlobalLevel = true) { 2038| | // If map is empty and we are allowed to add into generic level (Level::Global), do it! 2039| 32.6k| if (confMap->empty() && includeGlobalLevel) { ------------------ | Branch (2039:9): [True: 4.07k, False: 28.5k] | Branch (2039:29): [True: 4.07k, False: 0] ------------------ 2040| 4.07k| confMap->insert(std::make_pair(Level::Global, value)); 2041| 4.07k| return; 2042| 4.07k| } 2043| | // If same value exist in generic level already, dont add it to explicit level 2044| 28.5k| typename std::unordered_map::iterator it = confMap->find(Level::Global); 2045| 28.5k| if (it != confMap->end() && it->second == value) { ------------------ | Branch (2045:9): [True: 28.5k, False: 0] | Branch (2045:9): [True: 28.5k, False: 0] | Branch (2045:33): [True: 28.5k, False: 0] ------------------ 2046| 28.5k| return; 2047| 28.5k| } 2048| | // Now make sure we dont double up values if we really need to add it to explicit level 2049| 0| it = confMap->find(level); 2050| 0| if (it == confMap->end()) { ------------------ | Branch (2050:9): [True: 0, False: 0] ------------------ 2051| | // Value not found for level, add new 2052| 0| confMap->insert(std::make_pair(level, value)); 2053| 0| } else { 2054| | // Value found, just update value 2055| 0| confMap->at(level) = value; 2056| 0| } 2057| 0| } _ZN2el4base19TypedConfigurations8setValueImEEvNS_5LevelERKT_PNSt3__113unordered_mapIS3_S4_NS7_4hashIS3_EENS7_8equal_toIS3_EENS7_9allocatorINS7_4pairIKS3_S4_EEEEEEb: 2037| 65.2k| bool includeGlobalLevel = true) { 2038| | // If map is empty and we are allowed to add into generic level (Level::Global), do it! 2039| 65.2k| if (confMap->empty() && includeGlobalLevel) { ------------------ | Branch (2039:9): [True: 8.15k, False: 57.1k] | Branch (2039:29): [True: 8.15k, False: 0] ------------------ 2040| 8.15k| confMap->insert(std::make_pair(Level::Global, value)); 2041| 8.15k| return; 2042| 8.15k| } 2043| | // If same value exist in generic level already, dont add it to explicit level 2044| 57.1k| typename std::unordered_map::iterator it = confMap->find(Level::Global); 2045| 57.1k| if (it != confMap->end() && it->second == value) { ------------------ | Branch (2045:9): [True: 57.1k, False: 0] | Branch (2045:9): [True: 57.1k, False: 0] | Branch (2045:33): [True: 57.1k, False: 0] ------------------ 2046| 57.1k| return; 2047| 57.1k| } 2048| | // Now make sure we dont double up values if we really need to add it to explicit level 2049| 0| it = confMap->find(level); 2050| 0| if (it == confMap->end()) { ------------------ | Branch (2050:9): [True: 0, False: 0] ------------------ 2051| | // Value not found for level, add new 2052| 0| confMap->insert(std::make_pair(level, value)); 2053| 0| } else { 2054| | // Value found, just update value 2055| 0| confMap->at(level) = value; 2056| 0| } 2057| 0| } _ZN2el4base5utils8RegistryINS_6LoggerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEC2Ev: 1413| 4.07k| Registry(void) {} _ZN2el4base5utils16AbstractRegistryINS_6LoggerENSt3__113unordered_mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPS3_NS4_4hashISB_EENS4_8equal_toISB_EENS9_INS4_4pairIKSB_SC_EEEEEEEC2Ev: 1299| 4.07k| AbstractRegistry(void) {} _ZN2el4base7Storage26installLogDispatchCallbackINS0_26DefaultLogDispatchCallbackEEEbRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE: 2708| 4.07k| inline bool installLogDispatchCallback(const std::string& id) { 2709| 4.07k| return base::utils::Utils::installCallback(id, &m_logDispatchCallbacks); 2710| 4.07k| } _ZN2el4base5utils5Utils15installCallbackINS0_26DefaultLogDispatchCallbackENSt3__110shared_ptrINS_19LogDispatchCallbackEEEEEbRKNS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEPNS5_13unordered_mapISE_T0_NS5_4hashISE_EENS5_8equal_toISE_EENSC_INS5_4pairISF_SI_EEEEEE: 1572| 4.07k| static bool installCallback(const std::string& id, std::unordered_map* mapT) { 1573| 4.07k| if (mapT->find(id) == mapT->end()) { ------------------ | Branch (1573:9): [True: 4.07k, False: 0] ------------------ 1574| 4.07k| mapT->insert(std::make_pair(id, TPtr(new T()))); 1575| 4.07k| return true; 1576| 4.07k| } 1577| 0| return false; 1578| 4.07k| } _ZN2el8CallbackINS_15LogDispatchDataEEC2Ev: 2184| 4.07k| Callback(void) : m_enabled(true) {} easylogging++.cc:_ZN2el4base5utilsL10safeDeleteINS0_21RegisteredHitCountersEEENSt3__19enable_ifIXsr3std10is_pointerIPT_EE5valueEvE4typeERS7_: 889| 4.07k|safeDelete(T*& pointer) { 890| 4.07k| if (pointer == nullptr) ------------------ | Branch (890:7): [True: 0, False: 4.07k] ------------------ 891| 0| return; 892| 4.07k| delete pointer; 893| 4.07k| pointer = nullptr; 894| 4.07k|} easylogging++.cc:_ZN2el4base5utilsL10safeDeleteINS0_17RegisteredLoggersEEENSt3__19enable_ifIXsr3std10is_pointerIPT_EE5valueEvE4typeERS7_: 889| 4.07k|safeDelete(T*& pointer) { 890| 4.07k| if (pointer == nullptr) ------------------ | Branch (890:7): [True: 0, False: 4.07k] ------------------ 891| 0| return; 892| 4.07k| delete pointer; 893| 4.07k| pointer = nullptr; 894| 4.07k|} easylogging++.cc:_ZN2el4base5utilsL10safeDeleteINS0_9VRegistryEEENSt3__19enable_ifIXsr3std10is_pointerIPT_EE5valueEvE4typeERS7_: 889| 4.07k|safeDelete(T*& pointer) { 890| 4.07k| if (pointer == nullptr) ------------------ | Branch (890:7): [True: 0, False: 4.07k] ------------------ 891| 0| return; 892| 4.07k| delete pointer; 893| 4.07k| pointer = nullptr; 894| 4.07k|} easylogging++.cc:_ZN2el4base5utilsL10safeDeleteINS_13ConfigurationEEENSt3__19enable_ifIXsr3std10is_pointerIPT_EE5valueEvE4typeERS7_: 889| 587k|safeDelete(T*& pointer) { 890| 587k| if (pointer == nullptr) ------------------ | Branch (890:7): [True: 0, False: 587k] ------------------ 891| 0| return; 892| 587k| delete pointer; 893| 587k| pointer = nullptr; 894| 587k|} LLVMFuzzerTestOneInput: 39| 8.91k|BEGIN_SIMPLE_FUZZER() ------------------ | | 53| 4.45k| { \ | | 54| 4.45k| try \ | | 55| 4.45k| { \ | | 56| 4.45k| static bool first = true; \ | | 57| 4.45k| if (first) \ | | ------------------ | | | Branch (57:11): [True: 1, False: 4.45k] | | ------------------ | | 58| 4.45k| { \ | | 59| 1| if (init()) \ | | ------------------ | | | Branch (59:13): [True: 0, False: 1] | | ------------------ | | 60| 1| return 1; \ | | 61| 1| first = false; \ | | 62| 1| } \ ------------------ 40| 4.45k| epee::serialization::portable_storage ps; 41| 4.45k| ps.load_from_binary(std::string((const char*)buf, len)); 42| 4.45k|END_SIMPLE_FUZZER() ------------------ | | 65| 4.45k| } \ | | 66| 4.45k| catch (const std::exception &e) \ | | 67| 4.45k| { \ | | 68| 0| fprintf(stderr, "Exception: %s\n", e.what()); \ | | 69| 0| delete el::base::elStorage; \ | | 70| 0| el::base::elStorage = NULL; \ | | 71| 0| return 0; \ | | 72| 0| } \ | | 73| 4.45k| delete el::base::elStorage; \ | | 74| 4.45k| el::base::elStorage = NULL; \ | | 75| 4.45k| return 0; \ | | 76| 4.45k| } \ ------------------ load_from_binary.cpp:_ZL4initv: 36| 2|BEGIN_INIT_SIMPLE_FUZZER() ------------------ | | 36| 1| { \ | | 37| 1| try \ | | 38| 1| { ------------------ 37| 2|END_INIT_SIMPLE_FUZZER() ------------------ | | 41| 1| } \ | | 42| 1| catch (const std::exception &e) \ | | 43| 1| { \ | | 44| 0| fprintf(stderr, "Exception: %s\n", e.what()); \ | | 45| 0| return 1; \ | | 46| 0| } \ | | 47| 1| return 0; \ | | 48| 1| } ------------------